@situm/cordova 3.0.0

package/src/ios/situmcordovaplugintests/TestingHelper.h

@@ -0,0 +1,48 @@
+//
+//  TestingHelper.h
+//  situmcordovapluginTests
+//
+//  Created by Situm on 24/7/18.
+//  Copyright © 2018 Situm. All rights reserved.
+//
+
+#import <XCTest/XCTest.h>
+#import <Foundation/Foundation.h>
+#import "SitumLocationWrapper.h"
+
+@interface TestingHelper : XCTestCase 
+
+
++ (id)dataFromJSONFileNamed:(NSString *)fileName inDirectory:(NSString *) pathResources;
+- (void) assertCoordinate: (NSDictionary *) jsonCoordinateFile : (NSDictionary *) coordinateJO;
+- (void) assertCartesianCoordinate: (NSDictionary *) jsonCartesianCoordinateFile : (NSDictionary *) cartesianCoordinateJO;
+- (void) assertAngle: (NSDictionary *) jsonAngleFile : (NSDictionary *) angleJO;
+- (void) assertBound: (NSDictionary *) jsonBoundFile : (NSDictionary *) boundJO;
+- (void) assertBuilding: (NSDictionary *) jsonBuildingFile : (NSDictionary *) buildingJO;
+- (void) assertDimension: (NSDictionary *) jsonDimensionFile : (NSDictionary *) dimensionJO;
+- (void) assertEvent: (NSDictionary *) jsonEventFile : (NSDictionary *) eventJO;
+- (void) assertFloor: (NSDictionary *) jsonFloorFile : (NSDictionary *) floorJO;
+- (void) assertIndication: (NSDictionary *) jsonIndicationFile : (NSDictionary *) indicationJO;
+- (void) assertLocation: (NSDictionary *) jsonLocationFile : (NSDictionary *) locationJO;
+- (void) assertLocationStatus: (NSDictionary *) jsonLocationStatusFile : (NSDictionary *) locationStatusJO;
+- (void) assertNavigationProgress: (NSDictionary *) jsonNavigationProgressFile : (NSDictionary *) navigationProgressJO;
+- (void) assertPoi: (NSDictionary *) jsonPoiFile : (NSDictionary *) poiJO;
+- (void) assertImage: (NSDictionary *) jsonImageFile : (NSDictionary *) imageJO;
+- (void) assertPoint: (NSDictionary *) jsonPointFile : (NSDictionary *) pointJO;
+- (void) assertRoute: (NSDictionary *) jsonRouteFile : (NSDictionary *) routeJO;
+- (void) assertRouteStep: (NSDictionary *) jsonRouteStepFile : (NSDictionary *) routeStepJO;
+- (void) assertConversionArea:(NSDictionary *) jsonConversionAreaFile : (NSDictionary *) conversionAreaJO;
+
+#pragma MARK Input tests methods
+
+- (void) assertCoordinate: (CLLocationCoordinate2D) coordinateA isEqualToCoordinate: (CLLocationCoordinate2D) coordinateB;
+- (void) assertCartesianCoordinate: (SITCartesianCoordinate*) coordinateA isEqualToCartesianCoordinate: (SITCartesianCoordinate*) coordinateB;
+- (void) assertPoint: (SITPoint*) pointA isEqualToPoint: (SITPoint*) pointB;
+- (void) assertLocationRequest: (SITLocationRequest *) requestA isEqualToLocationRequest: (SITLocationRequest *) requestB;
+- (void) assertDirectionsRequest: (SITDirectionsRequest *) requestA isEqualToDirectionsRequest: (SITDirectionsRequest *) requestB;
+- (void) assertLocation: (SITLocation*) locationA isEqualToLocation: (SITLocation*) locationB;
+- (void) assertPoiCategory: (SITPOICategory*) poiCategoryA isEqualToPoiCategory: (SITPOICategory*) poiCategoryB;
+- (void) assertIndication: (SITIndication*) indicationA isEqualToIndication: (SITIndication*) indicationB;
+- (void) assertFloor: (SITFloor *) floorA isEqualToFloor :(SITFloor *) floorB;
+
+@end

package/src/ios/situmcordovaplugintests/TestingHelper.m

@@ -0,0 +1,342 @@
+//
+//  TestingHelper.m
+//  situmcordovapluginTests
+//
+//  Created by Situm on 24/7/18.
+//  Copyright © 2018 Situm. All rights reserved.
+//
+#import "TestingHelper.h"
+#import <XCTest/XCTest.h>
+
+
+
+@implementation TestingHelper
+
++ (id)dataFromJSONFileNamed:(NSString *)fileName inDirectory: (NSString *)pathResources {
+    //get file path relative to project for avoiding CI integration problems
+    NSString *filePath = [[NSBundle bundleForClass:[self class]] pathForResource:fileName
+                                                         ofType:@"json"
+                                                    inDirectory:pathResources];
+    NSDictionary *json = [[NSMutableDictionary alloc] init];
+    //check file exists
+    if (filePath) {
+        //retrieve file content
+        NSData *data = [[NSData alloc] initWithContentsOfFile:filePath];
+        
+        //convert JSON NSData to a usable NSDictionary
+        NSError *error;
+        json = [NSJSONSerialization JSONObjectWithData:data
+                                               options:0
+                                                 error:&error];
+        if (error) {
+            NSLog(@"Something went wrong! %@", error.localizedDescription);
+        }
+    }
+    else {
+        NSLog(@"Couldn't find file!");
+    }
+    return json.copy;
+}
+
+- (void) assertCoordinate: (NSDictionary *) jsonCoordinateFile : (NSDictionary *) coordinateJO {
+    XCTAssertEqualWithAccuracy([jsonCoordinateFile[@"longitude"] doubleValue], [coordinateJO[@"longitude"] doubleValue], 0.001);
+    XCTAssertEqualWithAccuracy([jsonCoordinateFile[@"latitude"] doubleValue], [coordinateJO[@"latitude"] doubleValue], 0.001);
+}
+
+- (void) assertCartesianCoordinate: (NSDictionary *) jsonCartesianCoordinateFile : (NSDictionary *) cartesianCoordinateJO {
+    XCTAssertEqualWithAccuracy([jsonCartesianCoordinateFile[@"x"] doubleValue], [cartesianCoordinateJO[@"x"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonCartesianCoordinateFile[@"y"] doubleValue], [cartesianCoordinateJO[@"y"] doubleValue], 0.0001);
+}
+
+- (void) assertAngle: (NSDictionary *) jsonAngleFile : (NSDictionary *) angleJO;
+{
+    XCTAssertEqualWithAccuracy([jsonAngleFile[@"radiansMinusPiPi"] doubleValue], [angleJO[@"radiansMinusPiPi"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonAngleFile[@"radians"] doubleValue], [angleJO[@"radians"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonAngleFile[@"degreesClockwise"] doubleValue], [angleJO[@"degreesClockwise"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonAngleFile[@"degrees"] doubleValue], [angleJO[@"degrees"] doubleValue], 0.0001);
+}
+
+- (void) assertBound: (NSDictionary *) jsonBoundFile : (NSDictionary *) boundJO {
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"northWest"][@"latitude"] doubleValue], [boundJO[@"northWest"][@"latitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"northWest"][@"longitude"] doubleValue], [boundJO[@"northWest"][@"longitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"northEast"][@"latitude"] doubleValue], [boundJO[@"northEast"][@"latitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"northEast"][@"longitude"] doubleValue], [boundJO[@"northEast"][@"longitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"southWest"][@"latitude"] doubleValue], [boundJO[@"southWest"][@"latitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"southWest"][@"longitude"] doubleValue], [boundJO[@"southWest"][@"longitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"southEast"][@"latitude"] doubleValue], [boundJO[@"southEast"][@"latitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonBoundFile[@"southEast"][@"longitude"] doubleValue], [boundJO[@"southEast"][@"longitude"] doubleValue], 0.0001);
+}
+
+- (void) assertBuilding: (NSDictionary *) jsonBuildingFile : (NSDictionary *) buildingJO {
+    XCTAssertEqualObjects(jsonBuildingFile[@"address"], buildingJO[@"address"]);
+    [self assertBound: jsonBuildingFile[@"bounds"][@"northEast"]: buildingJO[@"bounds"][@"northEast"]];
+    [self assertBound: jsonBuildingFile[@"bounds"][@"northWest"]: buildingJO[@"bounds"][@"northWest"]];
+    [self assertBound: jsonBuildingFile[@"bounds"][@"southEast"]: buildingJO[@"bounds"][@"southEast"]];
+    [self assertBound: jsonBuildingFile[@"bounds"][@"southWest"]: buildingJO[@"bounds"][@"southWest"]];
+    [self assertBound: jsonBuildingFile[@"boundsRotated"][@"northEast"]: buildingJO[@"boundsRotated"][@"northEast"]];
+    [self assertBound: jsonBuildingFile[@"boundsRotated"][@"northWest"]: buildingJO[@"boundsRotated"][@"northWest"]];
+    [self assertBound: jsonBuildingFile[@"boundsRotated"][@"southEast"]: buildingJO[@"boundsRotated"][@"southEast"]];
+    [self assertBound: jsonBuildingFile[@"boundsRotated"][@"southWest"]: buildingJO[@"boundsRotated"][@"southWest"]];
+    [self assertBound: jsonBuildingFile[@"center"]: buildingJO[@"center"]];
+    [self assertDimension: jsonBuildingFile[@"dimensions"]: buildingJO[@"dimensions"]];
+    XCTAssertEqualObjects(jsonBuildingFile[@"infoHtml"], buildingJO[@"infoHtml"]);
+    XCTAssertEqualObjects(jsonBuildingFile[@"pictureThumbUrl"], buildingJO[@"pictureThumbUrl"]);
+    XCTAssertEqualObjects(jsonBuildingFile[@"pictureUrl"], buildingJO[@"pictureUrl"]);
+    XCTAssertEqualWithAccuracy([jsonBuildingFile[@"pictureUrl"] doubleValue], [buildingJO[@"pictureUrl"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonBuildingFile[@"name"], buildingJO[@"name"]);
+    XCTAssertEqualWithAccuracy([jsonBuildingFile[@"rotation"] doubleValue], [buildingJO[@"rotation"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonBuildingFile[@"updatedAt"], buildingJO[@"updatedAt"]);
+    XCTAssertEqualObjects(jsonBuildingFile[@"createdAt"], buildingJO[@"createdAt"]);
+    XCTAssertEqualObjects(jsonBuildingFile[@"userIdentifier"], buildingJO[@"userIdentifier"]);
+    XCTAssertEqualObjects(jsonBuildingFile[@"customFields"], buildingJO[@"customFields"]);
+}
+
+- (void) assertDimension: (NSDictionary *) jsonDimensionFile : (NSDictionary *) dimensionJO {
+    XCTAssertEqualWithAccuracy([jsonDimensionFile[@"width"] doubleValue], [dimensionJO[@"width"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonDimensionFile[@"height"] doubleValue], [dimensionJO[@"height"] doubleValue], 0.0001);
+}
+
+- (void) assertEvent: (NSDictionary *) jsonEventFile : (NSDictionary *) eventJO {
+    XCTAssertEqualObjects(jsonEventFile[@"identifier"], eventJO[@"identifier"]);
+    XCTAssertEqualObjects(jsonEventFile[@"buildingIdentifier"], eventJO[@"buildingIdentifier"]);
+    XCTAssertEqualObjects(jsonEventFile[@"infoHtml"], eventJO[@"infoHtml"]);
+    [self assertCircularArea:jsonEventFile[@"trigger"] :eventJO[@"trigger"]];
+    [self assertCircularArea:jsonEventFile[@"conversion"] :eventJO[@"conversion"]];
+    XCTAssertEqualObjects(jsonEventFile[@"name"], eventJO[@"name"]);
+    XCTAssertEqualObjects(jsonEventFile[@"customFields"], eventJO[@"customFields"]);
+}
+
+- (void) assertCircularArea: (NSDictionary *) jsonCircularAreaFile : (NSDictionary *) circularAreaJO {
+    [self assertPoint:jsonCircularAreaFile[@"center"] :circularAreaJO[@"center"]];
+    XCTAssertEqualObjects(jsonCircularAreaFile[@"radius"], circularAreaJO[@"radius"]);
+}
+
+- (void) assertFloor: (NSDictionary *) jsonFloorFile : (NSDictionary *) floorJO {
+    XCTAssertEqualWithAccuracy([jsonFloorFile[@"altitude"] doubleValue], [floorJO[@"altitude"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonFloorFile[@"level"] doubleValue], [floorJO[@"level"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonFloorFile[@"scale"] doubleValue], [floorJO[@"scale"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonFloorFile[@"floorIdentifier"], jsonFloorFile[@"floorIdentifier"]);
+    XCTAssertEqualObjects(jsonFloorFile[@"mapUrl"], jsonFloorFile[@"mapUrl"]);
+    XCTAssertEqualObjects(jsonFloorFile[@"buildingIdentifier"], jsonFloorFile[@"buildingIdentifier"]);
+    XCTAssertEqualObjects(jsonFloorFile[@"createdAt"], jsonFloorFile[@"createdAt"]);
+    XCTAssertEqualObjects(jsonFloorFile[@"updatedAt"], jsonFloorFile[@"updatedAt"]);
+}
+
+- (void) assertIndication: (NSDictionary *) jsonIndicationFile : (NSDictionary *) indicationJO {
+    XCTAssertEqualWithAccuracy([jsonIndicationFile[@"orientation"] doubleValue], [indicationJO[@"orientation"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonIndicationFile[@"stepIdxDestination"] doubleValue], [indicationJO[@"stepIdxDestination"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonIndicationFile[@"distance"] doubleValue], [indicationJO[@"distance"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonIndicationFile[@"stepIdxOrigin"] doubleValue], [indicationJO[@"stepIdxOrigin"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonIndicationFile[@"distanceToNextLevel"] doubleValue], [indicationJO[@"distanceToNextLevel"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonIndicationFile[@"orientationType"], indicationJO[@"orientationType"]);
+    XCTAssertEqualObjects(jsonIndicationFile[@"indicationType"], indicationJO[@"indicationType"]);
+    XCTAssertEqualObjects(jsonIndicationFile[@"stepIdxOrigin"], indicationJO[@"stepIdxOrigin"]);
+    XCTAssertEqualObjects(jsonIndicationFile[@"buildingIdentifier"], indicationJO[@"buildingIdentifier"]);
+    XCTAssertEqualObjects(jsonIndicationFile[@"neededLevelChange"], indicationJO[@"neededLevelChange"]);
+}
+
+- (void) assertLocation: (NSDictionary *) jsonLocationFile : (NSDictionary *) locationJO {
+    XCTAssertEqualObjects(jsonLocationFile[@"accuracy"], locationJO[@"accuracy"]);
+    XCTAssertEqualObjects(jsonLocationFile[@"provider"], locationJO[@"provider"]);
+    XCTAssertEqualObjects(jsonLocationFile[@"buildingIdentifier"], locationJO[@"buildingIdentifier"]);
+    XCTAssertEqualObjects(jsonLocationFile[@"floorIdentifier"], locationJO[@"floorIdentifier"]);
+    XCTAssertEqualObjects(jsonLocationFile[@"bearingQuality"], locationJO[@"bearingQuality"]);
+    XCTAssertEqualObjects(jsonLocationFile[@"quality"], locationJO[@"quality"]);
+    [self assertPoint:jsonLocationFile[@"position"]:locationJO[@"position"]];
+    [self assertCoordinate:jsonLocationFile[@"coordinate"]:locationJO[@"coordinate"]];
+    [self assertCartesianCoordinate:jsonLocationFile[@"cartesianCoordinate"]:locationJO[@"cartesianCoordinate"]];
+    [self assertAngle:jsonLocationFile[@"cartesianBearing"]:locationJO[@"cartesianBearing"]];
+    XCTAssertEqual(jsonLocationFile[@"hasBearing"], locationJO[@"hasBearing"]);
+}
+
+- (void) assertLocationStatus: (NSDictionary *) jsonLocationStatusFile : (NSDictionary *) locationStatusJO;
+{
+    XCTAssert([jsonLocationStatusFile[@"statusName"] isEqualToString: locationStatusJO[@"statusName"]]);
+}
+
+- (void) assertNavigationProgress: (NSDictionary *) jsonNavigationProgressFile : (NSDictionary *) navigationProgressJO;
+{
+    [self assertIndication:jsonNavigationProgressFile[@"currentIndication"]:navigationProgressJO[@"currentIndication"]];
+    [self assertIndication:jsonNavigationProgressFile[@"nextIndication"]:navigationProgressJO[@"nextIndication"]];
+    XCTAssertEqualWithAccuracy([jsonNavigationProgressFile[@"distanceToEndStep"] doubleValue], [navigationProgressJO[@"distanceToEndStep"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonNavigationProgressFile[@"distanceToClosestPointInRoute"] doubleValue], [navigationProgressJO[@"distanceToClosestPointInRoute"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonNavigationProgressFile[@"closestPointInRoute"], jsonNavigationProgressFile[@"closestPointInRoute"]);
+    XCTAssertEqualWithAccuracy([jsonNavigationProgressFile[@"timeToEndStep"] doubleValue], [navigationProgressJO[@"timeToEndStep"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonNavigationProgressFile[@"timeToGoal"] doubleValue], [navigationProgressJO[@"timeToGoal"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonNavigationProgressFile[@"currentStepIndex"] doubleValue], [navigationProgressJO[@"currentStepIndex"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonNavigationProgressFile[@"distanceToGoal"] doubleValue], [navigationProgressJO[@"distanceToGoal"] doubleValue], 0.0001);
+}
+
+- (void) assertPoi: (NSDictionary *) jsonPoiFile : (NSDictionary *) poiJO {
+    XCTAssertEqualObjects(jsonPoiFile[@"identifier"], poiJO[@"identifier"]);
+    [self assertCoordinate:jsonPoiFile[@"coordinate"]:poiJO[@"coordinate"]];
+    XCTAssertEqualObjects(jsonPoiFile[@"poiName"], poiJO[@"poiName"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"customFields"], poiJO[@"customFields"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"isIndoor"], poiJO[@"isIndoor"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"infoHtml"], poiJO[@"infoHtml"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"buildingIdentifier"], poiJO[@"buildingIdentifier"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"isOutdoor"], poiJO[@"isOutdoor"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"createdAt"], poiJO[@"createdAt"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"floorIdentifier"], poiJO[@"floorIdentifier"]);
+    [self assertCartesianCoordinate:jsonPoiFile[@"cartesianCoordinate"] :poiJO[@"cartesianCoordinate"]];
+    [self assertPoint: jsonPoiFile[@"position"]:poiJO[@"position"]];
+    XCTAssertEqualObjects(jsonPoiFile[@"category"], poiJO[@"category"]);
+    XCTAssertEqualObjects(jsonPoiFile[@"updatedAt"], poiJO[@"updatedAt"]);
+}
+
+- (void) assertImage: (NSDictionary *) jsonImageFile : (NSDictionary *) imageJO {
+    XCTAssert([jsonImageFile[@"data"] isEqualToString: imageJO[@"data"]]);
+}
+
+- (void) assertPoint: (NSDictionary *) jsonPointFile : (NSDictionary *) pointJO {
+    [self assertCoordinate:jsonPointFile[@"coordinate"]:pointJO[@"coordinate"]];
+    [self assertCartesianCoordinate:jsonPointFile[@"cartesianCoordinate"]:pointJO[@"cartesianCoordinate"]];
+    XCTAssertEqualObjects(jsonPointFile[@"floorIdentifier"], pointJO[@"floorIdentifier"]);
+    XCTAssert(jsonPointFile[@"isIndoor"] == pointJO[@"isIndoor"]);
+    XCTAssertEqualObjects(jsonPointFile[@"buildingIdentifier"], pointJO[@"buildingIdentifier"]);
+    XCTAssert(jsonPointFile[@"isOutdoor"] == pointJO[@"isOutdoor"]);
+}
+
+- (void) assertRoute: (NSDictionary *) jsonRouteFile : (NSDictionary *) routeJO {
+    [self assertRouteStep:[jsonRouteFile[@"steps"] objectAtIndex:0]:[routeJO[@"steps"] objectAtIndex:0]];
+    [self assertRouteStep:[jsonRouteFile[@"steps"] objectAtIndex:1]:[routeJO[@"steps"] objectAtIndex:1]];
+    [self assertRouteStep:[jsonRouteFile[@"steps"] objectAtIndex:2]:[routeJO[@"steps"] objectAtIndex:2]];
+    [self assertIndication:[jsonRouteFile[@"indications"] objectAtIndex:0]:[routeJO[@"indications"] objectAtIndex:0]];
+    [self assertIndication:[jsonRouteFile[@"indications"] objectAtIndex:1]:[routeJO[@"indications"] objectAtIndex:1]];
+    [self assertIndication:[jsonRouteFile[@"indications"] objectAtIndex:2]:[routeJO[@"indications"] objectAtIndex:2]];
+    [self assertPoint:jsonRouteFile[@"from"]:routeJO[@"from"]];
+    //TODO review TO vs to
+    [self assertPoint:jsonRouteFile[@"TO"]:routeJO[@"to"]];
+    [self assertRouteSegment: [jsonRouteFile[@"segments"] objectAtIndex: 0] : [routeJO[@"segments"] objectAtIndex: 0]];
+    [self assertRouteSegment: [jsonRouteFile[@"segments"] objectAtIndex: 1] : [routeJO[@"segments"] objectAtIndex: 1]];
+}
+
+- (void) assertRouteStep: (NSDictionary *) jsonRouteStepFile : (NSDictionary *) routeStepJO;
+{
+    XCTAssertEqualObjects(jsonRouteStepFile[@"isFirst"], routeStepJO[@"isFirst"]);
+    //TODO review constructor for SITRouteStep and stepDistance parameter passed
+    XCTAssertEqualWithAccuracy([jsonRouteStepFile[@"distance"] doubleValue], [routeStepJO[@"distance"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonRouteStepFile[@"isLast"], routeStepJO[@"isLast"]);
+    XCTAssertEqualWithAccuracy([jsonRouteStepFile[@"distanceToGoal"] doubleValue], [routeStepJO[@"distanceToGoal"] doubleValue], 0.0001);
+    XCTAssertEqualObjects(jsonRouteStepFile[@"id"], routeStepJO[@"id"]);
+    [self assertPoint:jsonRouteStepFile[@"from"]:routeStepJO[@"from"]];
+    [self assertPoint:jsonRouteStepFile[@"TO"]:routeStepJO[@"TO"]];
+}
+
+- (void) assertRouteSegment: (NSDictionary *) jsonRouteStepFile : (NSDictionary *) routeStepJO {
+    
+    XCTAssertEqualObjects(jsonRouteStepFile[@"floorIdentifier"], routeStepJO[@"floorIdentifier"]);
+    for(int i = 0; i < [jsonRouteStepFile[@"points"] count]; i++) {
+        [self assertPoint: [jsonRouteStepFile[@"points"] objectAtIndex: i] : [routeStepJO[@"points"] objectAtIndex: i]];
+    }
+}
+
+- (void) assertConversionArea:(NSDictionary *) jsonConversionAreaFile : (NSDictionary *) conversionAreaJO;
+{
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"bottomLeft"][@"x"] doubleValue], [conversionAreaJO[@"bottomLeft"][@"x"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"bottomLeft"][@"y"] doubleValue], [conversionAreaJO[@"bottomLeft"][@"y"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"bottomRight"][@"x"] doubleValue], [conversionAreaJO[@"bottomRight"][@"x"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"bottomRight"][@"y"] doubleValue], [conversionAreaJO[@"bottomRight"][@"y"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"topLeft"][@"x"] doubleValue], [conversionAreaJO[@"topLeft"][@"x"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"topLeft"][@"y"] doubleValue], [conversionAreaJO[@"topLeft"][@"y"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"topRight"][@"x"] doubleValue], [conversionAreaJO[@"topRight"][@"x"] doubleValue], 0.0001);
+    XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"topRight"][@"y"] doubleValue], [conversionAreaJO[@"topRight"][@"y"] doubleValue], 0.0001);
+    //TODO floorIdentifier is set in indoorPoint
+    //XCTAssertEqualWithAccuracy([jsonConversionAreaFile[@"floorIdentifier"] doubleValue], [conversionAreaJO[@"floorIdentifier"] doubleValue], 0.0001);
+}
+
+- (void) assertCoordinate: (CLLocationCoordinate2D) coordinateA isEqualToCoordinate: (CLLocationCoordinate2D) coordinateB {
+    XCTAssertEqualWithAccuracy(coordinateA.latitude, coordinateB.latitude, 0.001, @"Coordinate: latitude wasn't equal.");
+    XCTAssertEqualWithAccuracy(coordinateA.longitude, coordinateB.longitude, 0.001, @"Coordinate: longitude wasn't equal.");
+}
+
+- (void) assertCartesianCoordinate: (SITCartesianCoordinate*) coordinateA isEqualToCartesianCoordinate: (SITCartesianCoordinate*) coordinateB {
+    XCTAssertEqualWithAccuracy(coordinateA.x, coordinateB.x, 0.0001, @"SITCartesianCoordinate: X value wasn't equal.");
+    XCTAssertEqualWithAccuracy(coordinateA.y, coordinateB.y, 0.0001, @"SITCartesianCoordinate: Y value wasn't equal.");
+}
+
+- (void) assertAngle: (SITAngle*) angleA isEqualToAngle: (SITAngle*) angleB {
+    XCTAssertEqualWithAccuracy(angleA.degrees, angleB.degrees, 0.0001);
+    XCTAssertEqualWithAccuracy(angleA.radians, angleB.radians, 0.0001);
+    XCTAssertEqualWithAccuracy(angleA.degressClockwise, angleB.degressClockwise, 0.0001);
+    XCTAssertEqualWithAccuracy(angleA.radiansMinusPiPi, angleB.radiansMinusPiPi, 0.0001);
+}
+
+- (void) assertPoint: (SITPoint*) pointA isEqualToPoint: (SITPoint*) pointB {
+    [self assertCoordinate: pointA.coordinate isEqualToCoordinate: pointB.coordinate];
+    [self assertCartesianCoordinate: pointA.cartesianCoordinate isEqualToCartesianCoordinate: pointB.cartesianCoordinate];
+    XCTAssertEqualObjects(pointA.buildingIdentifier, pointB.buildingIdentifier, @"SITPoint: building identifier wasn't equal.");
+    XCTAssertEqualObjects(pointA.floorIdentifier, pointB.floorIdentifier, @"SITPoint: floor identifier wasn't equal.");
+    XCTAssertTrue(pointA.isIndoor == pointB.isIndoor, @"SITPoint: isIndoor bool wasn't equal.");
+    XCTAssertTrue(pointA.isOutdoor == pointB.isOutdoor, @"SITPoint: isOutdoor bool  wasn't equal.");
+}
+
+- (void) assertLocationRequest: (SITLocationRequest *) requestA isEqualToLocationRequest: (SITLocationRequest *) requestB {
+    XCTAssertEqualObjects(requestA.buildingID, requestB.buildingID, @"LocationRequest: building identifier wasn't equal");
+    XCTAssertEqual(requestA.useDeadReckoning, requestB.useDeadReckoning, @"LocationRequest: useDeadReckoning value wasn't equal");
+    XCTAssertEqual(requestA.useGps, requestB.useGps, @"LocationRequest: useGps value wasn't equal");
+    XCTAssertEqual(requestA.updateInterval, requestB.updateInterval, @"LocationRequest: updateInterval wasn`t equal");
+    XCTAssertEqual(requestA.interval, requestB.interval, @"LocationRequest: interval wasn't equal");
+    XCTAssertEqual(requestA.smallestDisplacement, requestB.smallestDisplacement, @"LocationRequest: smallestDisplacement wasn't equal");
+}
+
+- (void) assertDirectionsRequest: (SITDirectionsRequest *) requestA isEqualToDirectionsRequest: (SITDirectionsRequest *) requestB {
+    [self assertPoint:requestA.origin isEqualToPoint:requestB.origin];
+    [self assertPoint:requestA.destination isEqualToPoint:requestB.destination];
+    XCTAssertEqual(requestA.options.count, requestB.options.count);
+    XCTAssertEqual(requestA.options[@"initialBearing"], requestB.options[@"initialBearing"]);
+    XCTAssertEqual(requestA.options[@"minimizeFloorChanges"], requestB.options[@"minimizeFloorChanges"]);
+    XCTAssertEqual(requestA.options[@"accessible"], requestB.options[@"accessible"]);
+}
+
+- (void) assertLocation: (SITLocation *) locationA isEqualToLocation:(SITLocation *)locationB {
+    XCTAssertEqualWithAccuracy(locationA.accuracy, locationB.accuracy, 0.001);
+    XCTAssertEqualObjects(locationA.provider, locationB.provider);
+    XCTAssertEqualObjects(locationA.deviceId, locationB.deviceId);
+    XCTAssertEqual(locationA.quality, locationB.quality);
+    XCTAssertEqual(locationA.bearingQuality, locationB.bearingQuality);
+    XCTAssertEqual(locationA.hasBearing, locationB.hasBearing);
+    [self assertPoint: locationA.position isEqualToPoint: locationB.position];
+    [self assertAngle: locationA.bearing isEqualToAngle: locationB.bearing];
+    [self assertAngle: locationA.cartesianBearing isEqualToAngle: locationB.cartesianBearing];
+}
+
+- (void) assertPoiCategory: (SITPOICategory*) poiCategoryA isEqualToPoiCategory: (SITPOICategory*) poiCategoryB {
+    XCTAssertEqualObjects(poiCategoryA.iconURL.direction, poiCategoryB.iconURL.direction);
+    XCTAssertEqualObjects(poiCategoryA.selectedIconURL.direction, poiCategoryB.selectedIconURL.direction);
+    XCTAssertEqualObjects(poiCategoryA.name.value , poiCategoryB.name.value);
+    XCTAssertEqualObjects(poiCategoryA.code, poiCategoryB.code);
+}
+
+- (void) assertIndication: (SITIndication*) indicationA isEqualToIndication: (SITIndication*) indicationB {    
+    XCTAssertEqual(indicationA.orientation, indicationB.orientation);
+    XCTAssertEqual(indicationA.originStepIndex, indicationB.originStepIndex);
+    XCTAssertEqual(indicationA.destinationStepIndex, indicationB.destinationStepIndex);
+    XCTAssertEqualWithAccuracy(indicationA.horizontalDistance, indicationB.horizontalDistance, 0.0001);
+    XCTAssertEqualWithAccuracy(indicationA.verticalDistance, indicationB.verticalDistance, 0.0001);
+    XCTAssertEqual(indicationA.needLevelChange, indicationB.needLevelChange);
+    XCTAssertEqual([indicationA.nextLevel intValue], [indicationB.nextLevel intValue]);
+    XCTAssertEqualWithAccuracy(indicationA.orientationChange, indicationB.orientationChange, 0.0001);
+    XCTAssertEqual(indicationA.orientation, indicationB.orientation);
+    XCTAssertEqual(indicationA.action, indicationB.action);
+}
+
+- (void) assertFloor: (SITFloor *) floorA isEqualToFloor :(SITFloor *) floorB {
+    XCTAssertEqualObjects(floorA.identifier, floorB.identifier);
+    XCTAssertEqualObjects(@(floorA.altitude), @(floorB.altitude));
+    XCTAssertEqualObjects(@(floorA.level), @(floorB.level));
+    XCTAssertEqualObjects(@(floorA.floor), @(floorB.floor));
+    XCTAssertEqualObjects(@(floorA.scale), @(floorB.scale));
+    [self assertUrl:floorA.mapURL isEqualToUrl:floorB.mapURL];
+    XCTAssertEqualObjects(floorA.buildingIdentifier, floorB.buildingIdentifier);
+    XCTAssertEqualObjects(floorA.customFields, floorB.customFields);
+    XCTAssertEqualObjects(floorA.createdAt, floorB.createdAt);
+    XCTAssertEqualObjects(floorA.updatedAt, floorB.updatedAt);
+}
+
+- (void) assertUrl: (SITURL *) urlA isEqualToUrl: (SITURL *) urlB {
+    XCTAssert(urlA.isAbsolute == urlB.isAbsolute);
+    XCTAssertEqualObjects(urlA.direction, urlB.direction);
+}
+
+@end

package/src/ios/situmcordovaplugintests/indicationTests.m

@@ -0,0 +1,43 @@
+//
+//  indicationTests.m
+//  situmcordovaplugintests
+//
+//  Created by Cristina Sánchez Barreiro on 13/09/2018.
+//
+
+#import <XCTest/XCTest.h>
+#import "SitumCreatorTests.h"
+#import "SitumLocationWrapper.h"
+#import "TestingHelper.h"
+
+@interface indicationTests : XCTestCase
+
+@property (nonatomic, strong) NSString *filePath;
+@property (nonatomic, strong) TestingHelper *helper;
+
+@end
+
+@implementation indicationTests
+
+- (void)setUp {
+    [super setUp];
+    _filePath = @"resources/indication";
+    _helper = [TestingHelper new];
+}
+
+- (void)tearDown {
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void) testIndication {
+    // ### INDICATION1.JSON ###
+    SITIndication *indication1 = [SitumCreatorTests createIndication];
+    NSDictionary *indicationJO1 = [SitumLocationWrapper.shared indicationToJsonObject:indication1];
+    NSString *fileName1 =  @"indication1";
+    //read from json object in resources
+    NSDictionary *jsonIndication1 = [TestingHelper dataFromJSONFileNamed: fileName1 inDirectory : _filePath];
+    [_helper assertIndication: jsonIndication1: indicationJO1];
+}
+
+@end

package/tests/common-resources/angle/angle1.json

@@ -0,0 +1,6 @@
+{
+	"radiansMinusPiPi": 0.8203047484373349,
+	"radians": 0.8203047484373349,
+	"degreesClockwise": 313,
+	"degrees": 47
+}

package/tests/common-resources/angle/angle2.json

@@ -0,0 +1,6 @@
+{
+  "radiansMinusPiPi":1.4,
+  "radians":1.4,
+  "degreesClockwise":279.78590868168476,
+  "degrees":80.21409131831524
+}

package/tests/common-resources/bounds/bounds1.json

@@ -0,0 +1,18 @@
+{
+  "northWest": {
+    "latitude": 2,
+    "longitude": 6
+  },
+  "southWest": {
+    "latitude": 2,
+    "longitude": 4
+  },
+  "northEast": {
+    "latitude": 6,
+    "longitude": 3
+  },
+  "southEast": {
+    "latitude": 5,
+    "longitude": 8
+  }
+}

package/tests/common-resources/bounds/bounds2.json

@@ -0,0 +1,18 @@
+{
+  "northWest": {
+    "latitude": 2,
+    "longitude": 6
+  },
+  "southWest": {
+    "latitude": 2,
+    "longitude": 4
+  },
+  "northEast": {
+    "latitude": 6,
+    "longitude": 3
+  },
+  "southEast": {
+    "latitude": 5,
+    "longitude": 8
+  }
+}

package/tests/common-resources/building/building1.json

@@ -0,0 +1,64 @@
+{
+    "address": "",
+    "bounds": {
+        "northEast": {
+            "latitude": 42.87253907829066,
+            "longitude": -8.562817801731425
+        },
+        "northWest": {
+            "latitude": 42.87253907829066,
+            "longitude": -8.563687573151498
+        },
+        "southEast": {
+            "latitude": 42.87215551039662,
+            "longitude": -8.562817801731425
+        },
+        "southWest": {
+            "latitude": 42.87215551039662,
+            "longitude": -8.563687573151498
+        }
+    },
+    "boundsRotated": {
+        "northEast": {
+            "latitude": 42.87210212173802,
+            "longitude": -8.56363479235278
+        },
+        "northWest": {
+            "latitude": 42.8722149069941,
+            "longitude": -8.562778644442083
+        },
+        "southEast": {
+            "latitude": 42.87247968165883,
+            "longitude": -8.56372673044084
+        },
+        "southWest": {
+            "latitude": 42.87259246691492,
+            "longitude": -8.56287058257683
+        }
+    },
+    "center": {
+        "latitude": 42.8723472943445,
+        "longitude": -8.56325268745422
+    },
+    "dimensions": {
+        "width": 71.0686153823893,
+        "height": 42.6106416714803
+    },
+    "infoHtml": "<p>http://Prueba/actualizador/recibirAlarmas</p>",
+    "name": "Ed. Emprendia - Situm",
+    "pictureThumbUrl": "",
+    "pictureUrl": "",
+    "rotation": -3.31881803875501,
+    "userIdentifier": "-1",
+    "buildingIdentifier": "1051",
+    "customFields": {
+        "notification_url": "http://testUrl.com",
+        "pin": "1234",
+        "positioning-mode": "Trilateration",
+        "beacons_uuids": "7f6cc424-aae2-47fd-b5e9-476ad15e4733, fa4b8d11-9c13-4ad9-9859-cecd41c58000, 1876b5fa-3e4b-4d09-9252-627032fe9312",
+        "filter-beacon": "56C98FAD0C9, D5784F5A73CA",
+        "asset-localization": "True"
+    },
+    "createdAt": "Wed Jan 04 18:41:43 +0000 2017",
+    "updatedAt": "Wed Sep 12 12:10:25 +0000 2018"
+}

package/tests/common-resources/cartesianCoordinate/cartesianCoordinate1.json

@@ -0,0 +1,4 @@
+{
+  "x":5,
+  "y":7
+}

package/tests/common-resources/circle/circle1.json

@@ -0,0 +1,17 @@
+{
+  "center": {
+    "coordinate": {
+      "latitude": 42.8723364829157,
+      "longitude": -8.56308907270432
+    },
+    "floorIdentifier": "2767",
+    "cartesianCoordinate": {
+      "x": 22.5865678493934,
+      "y": 24.8444747467106
+    },
+    "isIndoor": true,
+    "buildingIdentifier": "1051",
+    "isOutdoor": false
+  },
+  "radius" : 2.7458453630437
+}

package/tests/common-resources/coordinate/coordinate1.json

@@ -0,0 +1,4 @@
+{
+  "latitude":23,
+  "longitude":43
+}

package/tests/common-resources/dimensions/dimensions1.json

@@ -0,0 +1,4 @@
+{
+  "width":5,
+  "height":7
+}