[YAML] Add isLowerCase/isUpperCase/isHexString constraints (#13479)

vivien-apple · pull[bot] · commit 039535f21562 · 2022-05-16T20:20:48.000Z
diff --git a/examples/chip-tool/templates/partials/test_cluster.zapt b/examples/chip-tool/templates/partials/test_cluster.zapt
@@ -332,18 +332,23 @@ class {{filename}}: public TestCommand
                 {{~#*inline "item"}}{{asLowerCamelCase name}}{{/inline}}
                 VerifyOrReturn(CheckValuePresent("{{> item}}", {{> item}}));
               {{/if}}
-              {{#if expectedConstraints.type}}VerifyOrReturn(CheckConstraintType("{{>item}}", "", "{{expectedConstraints.type}}"));{{/if}}
-              {{~#if expectedConstraints.format}}VerifyOrReturn(CheckConstraintFormat("{{>item}}", "", "{{expectedConstraints.format}}"));{{/if}}
-              {{~#if expectedConstraints.startsWith}}VerifyOrReturn(CheckConstraintStartsWith("{{>item}}", {{>item}}, "{{expectedConstraints.startsWith}}"));{{/if}}
-              {{~#if expectedConstraints.endsWith}}VerifyOrReturn(CheckConstraintEndsWith("{{>item}}", {{>item}}, "{{expectedConstraints.endsWith}}"));{{/if}}
-              {{~#if expectedConstraints.minLength}}VerifyOrReturn(CheckConstraintMinLength("{{>item}}", {{>item}}.size(), {{expectedConstraints.minLength}}));{{/if}}
-              {{~#if expectedConstraints.maxLength}}VerifyOrReturn(CheckConstraintMaxLength("{{>item}}", {{>item}}.size(), {{expectedConstraints.maxLength}}));{{/if}}
-              {{~#if expectedConstraints.minValue}}VerifyOrReturn(CheckConstraintMinValue<{{chipType}}>("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.minValue type}}));{{/if}}
-              {{~#if expectedConstraints.maxValue}}VerifyOrReturn(CheckConstraintMaxValue<{{chipType}}>("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.maxValue type}}));{{/if}}
-              {{~#if expectedConstraints.notValue}}
-                VerifyOrReturn(CheckConstraintNotValue("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.notValue type}}));
-              {{else if (isLiteralNull expectedConstraints.notValue)}}
+              {{#if (hasProperty expectedConstraints "type")}}VerifyOrReturn(CheckConstraintType("{{>item}}", "", "{{expectedConstraints.type}}"));{{/if}}
+              {{~#if (hasProperty expectedConstraints "format")}}VerifyOrReturn(CheckConstraintFormat("{{>item}}", "", "{{expectedConstraints.format}}"));{{/if}}
+              {{~#if (hasProperty expectedConstraints "startsWith")}}VerifyOrReturn(CheckConstraintStartsWith("{{>item}}", {{>item}}, "{{expectedConstraints.startsWith}}"));{{/if}}
+              {{~#if (hasProperty expectedConstraints "endsWith")}}VerifyOrReturn(CheckConstraintEndsWith("{{>item}}", {{>item}}, "{{expectedConstraints.endsWith}}"));{{/if}}
+              {{~#if (hasProperty expectedConstraints "isUpperCase")}}VerifyOrReturn(CheckConstraintIsUpperCase("{{>item}}", {{>item}}, {{expectedConstraints.isUpperCase}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "isLowerCase")}}VerifyOrReturn(CheckConstraintIsLowerCase("{{>item}}", {{>item}}, {{expectedConstraints.isLowerCase}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "isHexString")}}VerifyOrReturn(CheckConstraintIsHexString("{{>item}}", {{>item}}, {{expectedConstraints.isHexString}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "minLength")}}VerifyOrReturn(CheckConstraintMinLength("{{>item}}", {{>item}}.size(), {{expectedConstraints.minLength}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "maxLength")}}VerifyOrReturn(CheckConstraintMaxLength("{{>item}}", {{>item}}.size(), {{expectedConstraints.maxLength}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "minValue")}}VerifyOrReturn(CheckConstraintMinValue<{{chipType}}>("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.minValue type}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "maxValue")}}VerifyOrReturn(CheckConstraintMaxValue<{{chipType}}>("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.maxValue type}}));{{/if}}
+              {{~#if (hasProperty expectedConstraints "notValue")}}
+                {{#if (isLiteralNull expectedConstraints.notValue)}}
                 VerifyOrReturn(CheckValueNonNull("{{>item}}", {{>item}}));
+                {{else}}
+                VerifyOrReturn(CheckConstraintNotValue("{{>item}}", {{>item}}, {{asTypedLiteral expectedConstraints.notValue type}}));
+                {{/if}}
               {{/if}}
             {{/if}}
 
diff --git a/src/app/tests/suites/TestConstraints.yaml b/src/app/tests/suites/TestConstraints.yaml
@@ -94,6 +94,77 @@ tests:
           constraints:
               endsWith: "**"
 
+    - label: "Write attribute CHAR_STRING Value"
+      command: "writeAttribute"
+      attribute: "char_string"
+      arguments:
+          value: "lowercase"
+
+    - label:
+          "Read attribute CHAR_STRING Value isLowerCase/isUpperCase Constraints"
+      command: "readAttribute"
+      attribute: "char_string"
+      response:
+          constraints:
+              isLowerCase: true
+              isUpperCase: false
+
+    - label: "Write attribute CHAR_STRING Value"
+      command: "writeAttribute"
+      attribute: "char_string"
+      arguments:
+          value: "UPPERCASE"
+
+    - label:
+          "Read attribute CHAR_STRING Value isLowerCase/isUpperCase Constraints"
+      command: "readAttribute"
+      attribute: "char_string"
+      response:
+          constraints:
+              isUpperCase: true
+              isLowerCase: false
+
+    - label: "Write attribute CHAR_STRING Value"
+      command: "writeAttribute"
+      attribute: "char_string"
+      arguments:
+          value: "lowUPPER"
+
+    - label:
+          "Read attribute CHAR_STRING Value isLowerCase/isUpperCase Constraints"
+      command: "readAttribute"
+      attribute: "char_string"
+      response:
+          constraints:
+              isUpperCase: false
+              isLowerCase: false
+
+    - label: "Write attribute CHAR_STRING Value"
+      command: "writeAttribute"
+      attribute: "char_string"
+      arguments:
+          value: "ABCDEF012V"
+
+    - label: "Read attribute CHAR_STRING Value isHexString Constraints"
+      command: "readAttribute"
+      attribute: "char_string"
+      response:
+          constraints:
+              isHexString: false
+
+    - label: "Write attribute CHAR_STRING Value"
+      command: "writeAttribute"
+      attribute: "char_string"
+      arguments:
+          value: "ABCDEF0123"
+
+    - label: "Read attribute CHAR_STRING Value isHexString Constraints"
+      command: "readAttribute"
+      attribute: "char_string"
+      response:
+          constraints:
+              isHexString: true
+
     - label: "Write attribute CHAR_STRING Value Back to Default Value"
       command: "writeAttribute"
       attribute: "char_string"
diff --git a/src/app/tests/suites/include/ConstraintsChecker.h b/src/app/tests/suites/include/ConstraintsChecker.h
@@ -90,6 +90,105 @@ class ConstraintsChecker
         return true;
     }
 
+    bool CheckConstraintIsUpperCase(const char * itemName, const chip::CharSpan current, bool expectUpperCase)
+    {
+        std::string value(current.data(), current.size());
+        return CheckConstraintIsUpperCase(itemName, value.c_str(), expectUpperCase);
+    }
+
+    bool CheckConstraintIsUpperCase(const char * itemName, const char * current, bool expectUpperCase)
+    {
+        bool isUpperCase = true;
+        for (size_t i = 0; i < strlen(current); i++)
+        {
+            if (!isupper(current[i]))
+            {
+                isUpperCase = false;
+                break;
+            }
+        }
+
+        if (expectUpperCase && !isUpperCase)
+        {
+            Exit(std::string(itemName) + " (\"" + std::string(current) + "\") is not an upppercase string");
+            return false;
+        }
+
+        if (!expectUpperCase && isUpperCase)
+        {
+            Exit(std::string(itemName) + " (\"" + std::string(current) + "\") is an upppercase string");
+            return false;
+        }
+
+        return true;
+    }
+
+    bool CheckConstraintIsLowerCase(const char * itemName, const chip::CharSpan current, bool expectLowerCase)
+    {
+        std::string value(current.data(), current.size());
+        return CheckConstraintIsLowerCase(itemName, value.c_str(), expectLowerCase);
+    }
+
+    bool CheckConstraintIsLowerCase(const char * itemName, const char * current, bool expectLowerCase)
+    {
+        bool isLowerCase = true;
+        for (size_t i = 0; i < strlen(current); i++)
+        {
+            if (isupper(current[i]))
+            {
+                isLowerCase = false;
+                break;
+            }
+        }
+
+        if (expectLowerCase && !isLowerCase)
+        {
+            Exit(std::string(itemName) + " (\"" + std::string(current) + "\") is not a lowercase string");
+            return false;
+        }
+
+        if (!expectLowerCase && isLowerCase)
+        {
+            Exit(std::string(itemName) + " (\"" + std::string(current) + "\") is a lowercase string");
+            return false;
+        }
+
+        return true;
+    }
+
+    bool CheckConstraintIsHexString(const char * itemName, const chip::CharSpan current, bool expectHexString)
+    {
+        std::string value(current.data(), current.size());
+        return CheckConstraintIsHexString(itemName, value.c_str(), expectHexString);
+    }
+
+    bool CheckConstraintIsHexString(const char * itemName, const char * current, bool expectHexString)
+    {
+        bool isHexString = true;
+        for (size_t i = 0; i < strlen(current); i++)
+        {
+            if (!isxdigit(current[i]))
+            {
+                isHexString = false;
+                break;
+            }
+        }
+
+        if (expectHexString && !isHexString)
+        {
+            Exit(std::string(itemName) + " (\"" + std::string(current) + "\") is not a hexadecimal string");
+            return false;
+        }
+
+        if (!expectHexString && isHexString)
+        {
+            Exit(std::string(itemName) + " (\"" + std::string(current) + "\") is a hexadecimal string");
+            return false;
+        }
+
+        return true;
+    }
+
     template <typename T>
     bool CheckConstraintMinValue(const char * itemName, T current, T expected)
     {
diff --git a/src/app/zap-templates/templates/app/helper.js b/src/app/zap-templates/templates/app/helper.js
@@ -685,6 +685,11 @@ function incrementDepth(depth)
   return depth + 1;
 }
 
+function hasProperty(obj, prop)
+{
+  return prop in obj;
+}
+
 //
 // Module exports
 //
@@ -695,6 +700,7 @@ exports.chip_endpoint_cluster_list          = chip_endpoint_cluster_list
 exports.asTypedLiteral                      = asTypedLiteral;
 exports.asLowerCamelCase                    = asLowerCamelCase;
 exports.asUpperCamelCase                    = asUpperCamelCase;
+exports.hasProperty                         = hasProperty;
 exports.hasSpecificAttributes               = hasSpecificAttributes;
 exports.asMEI                               = asMEI;
 exports.zapTypeToEncodableClusterObjectType = zapTypeToEncodableClusterObjectType;
diff --git a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt
@@ -108,57 +108,78 @@ ResponseHandler {{> subscribeDataCallback}} = nil;
         }
         {{/if}}
         {{#if hasExpectedConstraints}}
-        {{#if expectedConstraints.minLength}}
+        {{#if (hasProperty expectedConstraints "minLength")}}
         {
           {{> actualValue}}
           XCTAssertGreaterThanOrEqual([actualValue length], {{expectedConstraints.minLength}});
         }
         {{/if}}
-        {{#if expectedConstraints.startsWith}}
+        {{#if (hasProperty expectedConstraints "startsWith")}}
         {
           {{> actualValue}}
           XCTAssertTrue([actualValue hasPrefix:@"{{expectedConstraints.startsWith}}"]);
         }
         {{/if}}
-        {{#if expectedConstraints.endsWith}}
+        {{#if (hasProperty expectedConstraints "endsWith")}}
         {
           {{> actualValue}}
           XCTAssertTrue([actualValue hasSuffix:@"{{expectedConstraints.endsWith}}"]);
         }
         {{/if}}
-        {{#if expectedConstraints.maxLength}}
+        {{#if (hasProperty expectedConstraints "isLowerCase")}}
+        {
+          {{> actualValue}}
+          BOOL isLowerCase = [actualValue isEqualToString:[actualValue lowercaseString]];
+          XCTAssert{{#if expectedConstraints.isLowerCase}}True{{else}}False{{/if}}(isLowerCase);
+        }
+        {{/if}}
+        {{#if (hasProperty expectedConstraints "isUpperCase")}}
+        {
+          {{> actualValue}}
+          BOOL isUpperCase = [actualValue isEqualToString:[actualValue uppercaseString]];
+          XCTAssert{{#if expectedConstraints.isUpperCase}}True{{else}}False{{/if}}(isUpperCase);
+        }
+        {{/if}}
+        {{#if (hasProperty expectedConstraints "isHexString")}}
+        {
+          {{> actualValue}}
+          NSCharacterSet *chars = [[NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"] invertedSet];
+          BOOL isHexString = (NSNotFound == [actualValue rangeOfCharacterFromSet:chars].location);
+          XCTAssert{{#if expectedConstraints.isHexString}}True{{else}}False{{/if}}(isHexString);
+        }
+        {{/if}}
+        {{#if (hasProperty expectedConstraints "maxLength")}}
         {
           {{> actualValue}}
           XCTAssertLessThanOrEqual([actualValue length], {{expectedConstraints.maxLength}});
         }
         {{/if}}
-        {{#if expectedConstraints.minValue}}
+        {{#if (hasProperty expectedConstraints "minValue")}}
         {
           {{> actualValue}}
           if (actualValue != nil) {
             XCTAssertGreaterThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.minValue type}});
           }
         }
         {{/if}}
-        {{#if expectedConstraints.maxValue}}
+        {{#if (hasProperty expectedConstraints "maxValue")}}
         {
           {{> actualValue}}
           if (actualValue != nil) {
             XCTAssertLessThanOrEqual([actualValue  {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.maxValue type}});
           }
         }
         {{/if}}
-        {{#if expectedConstraints.notValue}}
+        {{#if (hasProperty expectedConstraints "notValue")}}
         {
           {{> actualValue}}
+        {{#if (isLiteralNull expectedConstraints.notValue)}}
+          XCTAssertFalse(actualValue == nil);
+        {{else}}
           if (actualValue != nil) {
             XCTAssertNotEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.notValue type}});
           }
-        }
-        {{else if (isLiteralNull expectedConstraints.notValue)}}
-        {
-          {{> actualValue}}
-          XCTAssertFalse(actualValue == nil);
+        {{/if}}
         }
         {{/if}}
         {{/if}}
diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h

Original file line number	Diff line number	Diff line change
`@@ -108,57 +108,78 @@ ResponseHandler {{> subscribeDataCallback}} = nil;`
`108`	`108`	`}`
`109`	`109`	`{{/if}}`
`110`	`110`	`{{#if hasExpectedConstraints}}`
`111`		`- {{#if expectedConstraints.minLength}}`
	`111`	`+ {{#if (hasProperty expectedConstraints "minLength")}}`
`112`	`112`	`{`
`113`	`113`	`{{> actualValue}}`
`114`	`114`	`XCTAssertGreaterThanOrEqual([actualValue length], {{expectedConstraints.minLength}});`
`115`	`115`	`}`
`116`	`116`	`{{/if}}`
`117`		`- {{#if expectedConstraints.startsWith}}`
	`117`	`+ {{#if (hasProperty expectedConstraints "startsWith")}}`
`118`	`118`	`{`
`119`	`119`	`{{> actualValue}}`
`120`	`120`	`XCTAssertTrue([actualValue hasPrefix:@"{{expectedConstraints.startsWith}}"]);`
`121`	`121`	`}`
`122`	`122`	`{{/if}}`
`123`		`- {{#if expectedConstraints.endsWith}}`
	`123`	`+ {{#if (hasProperty expectedConstraints "endsWith")}}`
`124`	`124`	`{`
`125`	`125`	`{{> actualValue}}`
`126`	`126`	`XCTAssertTrue([actualValue hasSuffix:@"{{expectedConstraints.endsWith}}"]);`
`127`	`127`	`}`
`128`	`128`	`{{/if}}`
`129`		`- {{#if expectedConstraints.maxLength}}`
	`129`	`+ {{#if (hasProperty expectedConstraints "isLowerCase")}}`
	`130`	`+ {`
	`131`	`+ {{> actualValue}}`
	`132`	`+ BOOL isLowerCase = [actualValue isEqualToString:[actualValue lowercaseString]];`
	`133`	`+ XCTAssert{{#if expectedConstraints.isLowerCase}}True{{else}}False{{/if}}(isLowerCase);`
	`134`	`+ }`
	`135`	`+ {{/if}}`
	`136`	`+ {{#if (hasProperty expectedConstraints "isUpperCase")}}`
	`137`	`+ {`
	`138`	`+ {{> actualValue}}`
	`139`	`+ BOOL isUpperCase = [actualValue isEqualToString:[actualValue uppercaseString]];`
	`140`	`+ XCTAssert{{#if expectedConstraints.isUpperCase}}True{{else}}False{{/if}}(isUpperCase);`
	`141`	`+ }`
	`142`	`+ {{/if}}`
	`143`	`+ {{#if (hasProperty expectedConstraints "isHexString")}}`
	`144`	`+ {`
	`145`	`+ {{> actualValue}}`
	`146`	`+ NSCharacterSet *chars = [[NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"] invertedSet];`
	`147`	`+ BOOL isHexString = (NSNotFound == [actualValue rangeOfCharacterFromSet:chars].location);`
	`148`	`+ XCTAssert{{#if expectedConstraints.isHexString}}True{{else}}False{{/if}}(isHexString);`
	`149`	`+ }`
	`150`	`+ {{/if}}`
	`151`	`+ {{#if (hasProperty expectedConstraints "maxLength")}}`
`130`	`152`	`{`
`131`	`153`	`{{> actualValue}}`
`132`	`154`	`XCTAssertLessThanOrEqual([actualValue length], {{expectedConstraints.maxLength}});`
`133`	`155`	`}`
`134`	`156`	`{{/if}}`
`135`		`- {{#if expectedConstraints.minValue}}`
	`157`	`+ {{#if (hasProperty expectedConstraints "minValue")}}`
`136`	`158`	`{`
`137`	`159`	`{{> actualValue}}`
`138`	`160`	`if (actualValue != nil) {`
`139`	`161`	`XCTAssertGreaterThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.minValue type}});`
`140`	`162`	`}`
`141`	`163`	`}`
`142`	`164`	`{{/if}}`
`143`		`- {{#if expectedConstraints.maxValue}}`
	`165`	`+ {{#if (hasProperty expectedConstraints "maxValue")}}`
`144`	`166`	`{`
`145`	`167`	`{{> actualValue}}`
`146`	`168`	`if (actualValue != nil) {`
`147`	`169`	`XCTAssertLessThanOrEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.maxValue type}});`
`148`	`170`	`}`
`149`	`171`	`}`
`150`	`172`	`{{/if}}`
`151`		`- {{#if expectedConstraints.notValue}}`
	`173`	`+ {{#if (hasProperty expectedConstraints "notValue")}}`
`152`	`174`	`{`
`153`	`175`	`{{> actualValue}}`
	`176`	`+ {{#if (isLiteralNull expectedConstraints.notValue)}}`
	`177`	`+ XCTAssertFalse(actualValue == nil);`
	`178`	`+ {{else}}`
`154`	`179`	`if (actualValue != nil) {`
`155`	`180`	`XCTAssertNotEqual([actualValue {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral expectedConstraints.notValue type}});`
`156`	`181`	`}`
`157`		`- }`
`158`		`- {{else if (isLiteralNull expectedConstraints.notValue)}}`
`159`		`- {`
`160`		`- {{> actualValue}}`
`161`		`- XCTAssertFalse(actualValue == nil);`
	`182`	`+ {{/if}}`
`162`	`183`	`}`
`163`	`184`	`{{/if}}`
`164`	`185`	`{{/if}}`