Rename TEST_VENDOR to EXAMPLE for consistency with the example.com domain name

Bug: 120851298
Test: m
Change-Id: I6c0a731f50a2ec3a8a00ca245282fece1091857f

3 files changed, 37 insertions, 34 deletions

diff --git a/nn/runtime/test/fibonacci_extension/FibonacciDriver.cpp b/nn/runtime/test/fibonacci_extension/FibonacciDriver.cpp
index 85a708b1a..cd1edb618 100644
--- a/nn/runtime/test/fibonacci_extension/FibonacciDriver.cpp
+++ b/nn/runtime/test/fibonacci_extension/FibonacciDriver.cpp
@@ -27,6 +27,8 @@
 
 #include "FibonacciExtension.h"
 
+#include <vector>
+
 namespace android {
 namespace nn {
 namespace sample_driver {
@@ -39,7 +41,7 @@ const uint32_t kTypeWithinExtensionMask = (1 << kLowBitsType) - 1;
 
 namespace fibonacci_op {
 
-constexpr char kOperationName[] = "TEST_VENDOR_FIBONACCI";
+constexpr char kOperationName[] = "EXAMPLE_FIBONACCI";
 
 constexpr uint32_t kNumInputs = 1;
 constexpr uint32_t kInputN = 0;
@@ -49,7 +51,7 @@ constexpr uint32_t kOutputTensor = 0;
 
 bool getFibonacciExtensionPrefix(const Model& model, uint16_t* prefix) {
     NN_RET_CHECK_EQ(model.extensionNameToPrefix.size(), 1u);  // Assumes no other extensions in use.
-    NN_RET_CHECK_EQ(model.extensionNameToPrefix[0].name, TEST_VENDOR_FIBONACCI_EXTENSION_NAME);
+    NN_RET_CHECK_EQ(model.extensionNameToPrefix[0].name, EXAMPLE_FIBONACCI_EXTENSION_NAME);
     *prefix = model.extensionNameToPrefix[0].prefix;
     return true;
 }
@@ -58,7 +60,7 @@ bool isFibonacciOperation(const Operation& operation, const Model& model) {
     int32_t operationType = static_cast<int32_t>(operation.type);
     uint16_t prefix;
     NN_RET_CHECK(getFibonacciExtensionPrefix(model, &prefix));
-    NN_RET_CHECK_EQ(operationType, (prefix << kLowBitsType) | TEST_VENDOR_FIBONACCI);
+    NN_RET_CHECK_EQ(operationType, (prefix << kLowBitsType) | EXAMPLE_FIBONACCI);
     return true;
 }
 
@@ -70,9 +72,9 @@ bool validate(const Operation& operation, const Model& model) {
     int32_t outputType = static_cast<int32_t>(model.operands[operation.outputs[0]].type);
     uint16_t prefix;
     NN_RET_CHECK(getFibonacciExtensionPrefix(model, &prefix));
-    NN_RET_CHECK(inputType == ((prefix << kLowBitsType) | TEST_VENDOR_INT64) ||
+    NN_RET_CHECK(inputType == ((prefix << kLowBitsType) | EXAMPLE_INT64) ||
                  inputType == ANEURALNETWORKS_TENSOR_FLOAT32);
-    NN_RET_CHECK(outputType == ((prefix << kLowBitsType) | TEST_VENDOR_TENSOR_QUANT64_ASYMM) ||
+    NN_RET_CHECK(outputType == ((prefix << kLowBitsType) | EXAMPLE_TENSOR_QUANT64_ASYMM) ||
                  outputType == ANEURALNETWORKS_TENSOR_FLOAT32);
     return true;
 }
@@ -126,7 +128,7 @@ bool execute(IOperationExecutionContext* context) {
     } else {
         uint64_t* output = context->getOutputBuffer<uint64_t>(kOutputTensor);
         Shape outputShape = context->getOutputShape(kOutputTensor);
-        auto outputQuant = reinterpret_cast<const TestVendorQuant64AsymmParams*>(
+        auto outputQuant = reinterpret_cast<const ExampleQuant64AsymmParams*>(
                 outputShape.extraParams.extension().data());
         return compute(n, outputQuant->scale, outputQuant->zeroPoint, output);
     }
@@ -144,24 +146,24 @@ const OperationRegistration* FibonacciOperationResolver::findOperation(
     uint16_t prefix = static_cast<int32_t>(operationType) >> kLowBitsType;
     uint16_t typeWithinExtension = static_cast<int32_t>(operationType) & kTypeWithinExtensionMask;
     // Assumes no other extensions in use.
-    return prefix != 0 && typeWithinExtension == TEST_VENDOR_FIBONACCI ? &operationRegistration
-                                                                       : nullptr;
+    return prefix != 0 && typeWithinExtension == EXAMPLE_FIBONACCI ? &operationRegistration
+                                                                   : nullptr;
 }
 
 Return<void> FibonacciDriver::getSupportedExtensions(getSupportedExtensions_cb cb) {
     cb(ErrorStatus::NONE,
        {
                {
-                       .name = TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
+                       .name = EXAMPLE_FIBONACCI_EXTENSION_NAME,
                        .operandTypes =
                                {
                                        {
-                                               .type = TEST_VENDOR_INT64,
+                                               .type = EXAMPLE_INT64,
                                                .isTensor = false,
                                                .byteSize = 8,
                                        },
                                        {
-                                               .type = TEST_VENDOR_TENSOR_QUANT64_ASYMM,
+                                               .type = EXAMPLE_TENSOR_QUANT64_ASYMM,
                                                .isTensor = true,
                                                .byteSize = 8,
                                        },
diff --git a/nn/runtime/test/fibonacci_extension/FibonacciDriver.h b/nn/runtime/test/fibonacci_extension/FibonacciDriver.h
index dc883022b..2ae6da0ea 100644
--- a/nn/runtime/test/fibonacci_extension/FibonacciDriver.h
+++ b/nn/runtime/test/fibonacci_extension/FibonacciDriver.h
@@ -41,7 +41,7 @@ class FibonacciOperationResolver : public IOperationResolver {
 };
 
 // A driver that implements FibonacciExtension.
-// The only supported operation is TEST_VENDOR_FIBONACCI.
+// The only supported operation is EXAMPLE_FIBONACCI.
 class FibonacciDriver : public SampleDriver {
    public:
     FibonacciDriver() : SampleDriver(kDriverName, FibonacciOperationResolver::get()) {}
diff --git a/nn/runtime/test/fibonacci_extension/FibonacciExtensionTest.cpp b/nn/runtime/test/fibonacci_extension/FibonacciExtensionTest.cpp
index 04ccfca07..cdafa344f 100644
--- a/nn/runtime/test/fibonacci_extension/FibonacciExtensionTest.cpp
+++ b/nn/runtime/test/fibonacci_extension/FibonacciExtensionTest.cpp
@@ -29,6 +29,8 @@
 #include "FibonacciDriver.h"
 #include "FibonacciExtension.h"
 
+#include <vector>
+
 namespace android {
 namespace nn {
 namespace {
@@ -62,10 +64,10 @@ class FibonacciExtensionTest : public ::testing::Test {
             ANeuralNetworksDevice* device = nullptr;
             EXPECT_EQ(ANeuralNetworks_getDevice(i, &device), ANEURALNETWORKS_NO_ERROR);
             bool supportsFibonacciExtension;
-            ASSERT_EQ(ANeuralNetworksDevice_getExtensionSupport(
-                              device, TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                              &supportsFibonacciExtension),
-                      ANEURALNETWORKS_NO_ERROR);
+            ASSERT_EQ(
+                    ANeuralNetworksDevice_getExtensionSupport(
+                            device, EXAMPLE_FIBONACCI_EXTENSION_NAME, &supportsFibonacciExtension),
+                    ANEURALNETWORKS_NO_ERROR);
             if (supportsFibonacciExtension) {
                 ASSERT_EQ(fibonacciDevice, nullptr) << "Found multiple Fibonacci drivers";
                 fibonacciDevice = device;
@@ -150,9 +152,9 @@ void createModel(ExtensionModel* model, ExtensionOperandType inputType,
     if (addNopOperations) {
         addNopOperation(model, inputType, modelInput, fibonacciInput);
     }
-    model->addOperation(model->getExtensionOperationType(TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                                                         TEST_VENDOR_FIBONACCI),
-                        {fibonacciInput}, {fibonacciOutput});
+    model->addOperation(
+            model->getExtensionOperationType(EXAMPLE_FIBONACCI_EXTENSION_NAME, EXAMPLE_FIBONACCI),
+            {fibonacciInput}, {fibonacciOutput});
     if (addNopOperations) {
         addNopOperation(model, outputType, fibonacciOutput, modelOutput);
     }
@@ -167,15 +169,14 @@ TEST_F(FibonacciExtensionTest, ModelWithExtensionOperandTypes) {
     constexpr double scale = 0.5;
     constexpr int64_t zeroPoint = 10;
 
-    ExtensionOperandType inputType(
-            static_cast<Type>(mModel.getExtensionOperandType(TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                                                             TEST_VENDOR_INT64)),
-            {});
+    ExtensionOperandType inputType(static_cast<Type>(mModel.getExtensionOperandType(
+                                           EXAMPLE_FIBONACCI_EXTENSION_NAME, EXAMPLE_INT64)),
+                                   {});
     ExtensionOperandType outputType(
-            static_cast<Type>(mModel.getExtensionOperandType(TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                                                             TEST_VENDOR_TENSOR_QUANT64_ASYMM)),
+            static_cast<Type>(mModel.getExtensionOperandType(EXAMPLE_FIBONACCI_EXTENSION_NAME,
+                                                             EXAMPLE_TENSOR_QUANT64_ASYMM)),
             {N},
-            ExtensionOperandParams(TestVendorQuant64AsymmParams{
+            ExtensionOperandParams(ExampleQuant64AsymmParams{
                     .scale = scale,
                     .zeroPoint = zeroPoint,
             }));
@@ -282,9 +283,9 @@ TEST_F(FibonacciExtensionTest, InvalidNumInputs) {
     uint32_t input1 = mModel.addOperand(&inputType);
     uint32_t input2 = mModel.addOperand(&inputType);  // Extra input.
     uint32_t output = mModel.addOperand(&outputType);
-    mModel.addOperation(mModel.getExtensionOperationType(TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                                                         TEST_VENDOR_FIBONACCI),
-                        {input1, input2}, {output});
+    mModel.addOperation(
+            mModel.getExtensionOperationType(EXAMPLE_FIBONACCI_EXTENSION_NAME, EXAMPLE_FIBONACCI),
+            {input1, input2}, {output});
     mModel.identifyInputsAndOutputs({input1, input2}, {output});
     mModel.finish();
     ASSERT_TRUE(mModel.isValid());
@@ -301,9 +302,9 @@ TEST_F(FibonacciExtensionTest, InvalidNumOutputs) {
     uint32_t input = mModel.addOperand(&inputType);
     uint32_t output1 = mModel.addOperand(&outputType);
     uint32_t output2 = mModel.addOperand(&outputType);  // Extra output.
-    mModel.addOperation(mModel.getExtensionOperationType(TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                                                         TEST_VENDOR_FIBONACCI),
-                        {input}, {output1, output2});
+    mModel.addOperation(
+            mModel.getExtensionOperationType(EXAMPLE_FIBONACCI_EXTENSION_NAME, EXAMPLE_FIBONACCI),
+            {input}, {output1, output2});
     mModel.identifyInputsAndOutputs({input}, {output1, output2});
     mModel.finish();
     ASSERT_TRUE(mModel.isValid());
@@ -320,8 +321,8 @@ TEST_F(FibonacciExtensionTest, InvalidOperation) {
     uint32_t input = mModel.addOperand(&inputType);
     uint32_t output = mModel.addOperand(&outputType);
     mModel.addOperation(mModel.getExtensionOperationType(
-                                TEST_VENDOR_FIBONACCI_EXTENSION_NAME,
-                                TEST_VENDOR_FIBONACCI + 1),  // This operation should not exist.
+                                EXAMPLE_FIBONACCI_EXTENSION_NAME,
+                                EXAMPLE_FIBONACCI + 1),  // This operation should not exist.
                         {input}, {output});
     mModel.identifyInputsAndOutputs({input}, {output});
     mModel.finish();