Class Invoke

tensorflow/lite/testing/parse_testdata.cc:255–301

Process an 'invoke' message, triggering execution of the test runner, as well as verification of outputs. An 'invoke' message looks like: invoke { id: xyz input: 1,2,1,1,1,2,3,4 output: 4,5,6 }

//     output: 4,5,6
//   }
class Invoke : public Message {
 public:
  explicit Invoke(TestRunner* test_runner) : test_runner_(test_runner) {
    expected_inputs_ = test_runner->GetInputs();
    expected_outputs_ = test_runner->GetOutputs();
  }

  void SetField(const std::string& name, const std::string& value) override {
    if (name == "id") {
      test_runner_->SetInvocationId(value);
    } else if (name == "input") {
      if (parsed_input_count_ >= expected_inputs_.size()) {
        return test_runner_->Invalidate("Too many inputs");
      }
      test_runner_->SetInput(expected_inputs_[parsed_input_count_], value);
      ++parsed_input_count_;
    } else if (name == "output") {
      if (parsed_output_count_ >= expected_outputs_.size()) {
        return test_runner_->Invalidate("Too many outputs");
      }
      test_runner_->SetExpectation(expected_outputs_[parsed_output_count_],
                                   value);
      ++parsed_output_count_;
    } else if (name == "output_shape") {
      if (parsed_output_shape_count_ >= expected_outputs_.size()) {
        return test_runner_->Invalidate("Too many output shapes");
      }
      test_runner_->SetShapeExpectation(
          expected_outputs_[parsed_output_shape_count_], value);
      ++parsed_output_shape_count_;
    }
  }
  void Finish() override {
    test_runner_->Invoke();
    test_runner_->CheckResults();
  }

 private:
  std::vector<int> expected_inputs_;
  std::vector<int> expected_outputs_;

  int parsed_input_count_ = 0;
  int parsed_output_count_ = 0;
  int parsed_output_shape_count_ = 0;

  TestRunner* test_runner_;
};

// Process an 'reshape' message, triggering resizing of the input tensors via
// the test runner. A 'reshape' message looks like: