diff options
author | Justin R. Miller <incanus@users.noreply.github.com> | 2016-09-16 11:46:22 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2016-09-16 11:46:22 -0700 |
commit | 0bd66d40ddf9e75f860fe18e7c80de9c840f48ac (patch) | |
tree | 43e4509dca2ad447cab14454b1da8a7bdfe445be /platform/darwin/test | |
parent | 767aedc6766d1dd277f674ae54894cfcf21a437a (diff) | |
download | qtlocation-mapboxgl-0bd66d40ddf9e75f860fe18e7c80de9c840f48ac.tar.gz |
[ios] fixes #6248: properly handle all NSNumber types in filters (#6290)
Diffstat (limited to 'platform/darwin/test')
-rw-r--r-- | platform/darwin/test/MGLExpressionTests.mm | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/platform/darwin/test/MGLExpressionTests.mm b/platform/darwin/test/MGLExpressionTests.mm new file mode 100644 index 0000000000..971f7d0e54 --- /dev/null +++ b/platform/darwin/test/MGLExpressionTests.mm @@ -0,0 +1,200 @@ +#import <XCTest/XCTest.h> + +#import <string> + +#import "NSExpression+MGLAdditions.h" + +@interface MGLExpressionTests : XCTestCase + +@end + +@implementation MGLExpressionTests + +#pragma mark - Utility + +- (NSComparisonPredicate *)equalityComparisonPredicateWithRightConstantValue:(id)rightConstantValue +{ + NSComparisonPredicate *predicate = [NSComparisonPredicate + predicateWithLeftExpression:[NSExpression expressionForKeyPath:@"foo"] + rightExpression:[NSExpression expressionForConstantValue:rightConstantValue] + modifier:NSDirectPredicateModifier + type:NSEqualToPredicateOperatorType + options:0]; + return predicate; +} + +#pragma mark - String Tests + +- (void)testExpressionConversionString +{ + NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@"bar"]; + mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssert(convertedValue.is<std::string>() == true); + XCTAssertEqualObjects(@(convertedValue.get<std::string>().c_str()), @"bar"); +} + +#pragma mark - Boolean Tests + +- (void)testExpressionConversionBooleanTrue +{ + NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@YES]; + mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssert(convertedValue.is<bool>() == true); + XCTAssert(convertedValue.get<bool>() == true); +} + +- (void)testExpressionConversionBooleanFalse +{ + NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@NO]; + mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssert(convertedValue.is<bool>() == true); + XCTAssert(convertedValue.get<bool>() == false); +} + +#pragma mark - Floating Point Tests + +- (void)testExpressionConversionDouble +{ + NSComparisonPredicate *predicate; + mbgl::Value convertedValue; + + predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithDouble:DBL_MIN]]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<double>()); + XCTAssertEqual(convertedValue.get<double>(), DBL_MIN); + + predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithDouble:DBL_MAX]]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<double>()); + XCTAssertEqual(convertedValue.get<double>(), DBL_MAX); +} + +- (void)testExpressionConversionFloat +{ + // Because we can't guarantee precision when using float, and because + // we warn the user to this effect in mgl_convertedValueWithValue:, + // we just check that things are in the ballpark here with integer values + // and some lower-precision checks. + + NSComparisonPredicate *predicate; + mbgl::Value convertedValue; + + predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:-1]]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<double>()); + XCTAssertEqual(convertedValue.get<double>(), -1); + + predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:1]]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<double>()); + XCTAssertEqual(convertedValue.get<double>(), 1); + + predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:-23.232342]]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<double>()); + XCTAssertLessThan(-23.24, convertedValue.get<double>()); + XCTAssertGreaterThan(-23.23, convertedValue.get<double>()); + + predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:23.232342]]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<double>()); + XCTAssertLessThan(23.23, convertedValue.get<double>()); + XCTAssertGreaterThan(23.24, convertedValue.get<double>()); +} + +#pragma mark - Integer Tests + +- (void)testExpressionNegativeIntegers +{ + NSComparisonPredicate *predicate; + mbgl::Value convertedValue; + + NSArray<NSNumber *> *minValues = @[ + [NSNumber numberWithShort: SHRT_MIN], + [NSNumber numberWithInt: INT_MIN], + [NSNumber numberWithLong: LONG_MIN], + [NSNumber numberWithLongLong: LLONG_MIN], + [NSNumber numberWithInteger: NSIntegerMin] + ]; + + NSArray<NSNumber *> *maxValues = @[ + [NSNumber numberWithShort: SHRT_MAX], + [NSNumber numberWithInt: INT_MAX], + [NSNumber numberWithLong: LONG_MAX], + [NSNumber numberWithLongLong: LLONG_MAX], + [NSNumber numberWithInteger: NSIntegerMax] + ]; + + // Negative integers should always come back as int64_t per mbgl::Value definition. + // We use the long long value because it can store the highest number on both 32- + // and 64-bit and won't overflow. + + for (NSNumber *min in minValues) + { + predicate = [self equalityComparisonPredicateWithRightConstantValue:min]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<int64_t>()); + XCTAssertEqual(convertedValue.get<int64_t>(), min.longLongValue); + } + + // Positive integers should always come back as uint64_t per mbgl::Value definition. + // We use the unsigned long long value because it can store the highest number on + // both 32- and 64-bit and won't overflow. + + for (NSNumber *max in maxValues) + { + predicate = [self equalityComparisonPredicateWithRightConstantValue:max]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<uint64_t>()); + XCTAssertEqual(convertedValue.get<uint64_t>(), max.unsignedLongLongValue); + } + +} + +- (void)testExpressionPositiveAndZeroIntegers +{ + NSComparisonPredicate *predicate; + mbgl::Value convertedValue; + + NSArray<NSNumber *> *minValues = @[ + [NSNumber numberWithUnsignedShort: 0], + [NSNumber numberWithUnsignedInt: 0], + [NSNumber numberWithUnsignedLong: 0], + [NSNumber numberWithUnsignedLongLong: 0], + [NSNumber numberWithUnsignedInteger: 0] + ]; + + NSArray<NSNumber *> *maxValues = @[ + [NSNumber numberWithUnsignedShort: USHRT_MAX], + [NSNumber numberWithUnsignedInt: UINT_MAX], + [NSNumber numberWithUnsignedLong: ULONG_MAX], + [NSNumber numberWithUnsignedLongLong: ULLONG_MAX], + [NSNumber numberWithUnsignedInteger: NSUIntegerMax] + ]; + + // Zero-value integers should always come back as uint64_t per mbgl::Value definition + // (using the interpretation that zero is not negative). We use the unsigned long long + // value just for parity with the positive integer test. + + for (NSNumber *min in minValues) + { + predicate = [self equalityComparisonPredicateWithRightConstantValue:min]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<uint64_t>()); + XCTAssertEqual(convertedValue.get<uint64_t>(), min.unsignedLongLongValue); + } + + // Positive integers should always come back as uint64_t per mbgl::Value definition. + // We use the unsigned long long value because it can store the highest number on + // both 32- and 64-bit and won't overflow. + + for (NSNumber *max in maxValues) + { + predicate = [self equalityComparisonPredicateWithRightConstantValue:max]; + convertedValue = predicate.rightExpression.mgl_filterValue; + XCTAssertTrue(convertedValue.is<uint64_t>()); + XCTAssertEqual(convertedValue.get<uint64_t>(), max.unsignedLongLongValue); + } +} + +@end |