TF_ASSERT_OK_AND_ASSIGN(auto key, BuildSampleSignature("foo"));
  Cache::Value cache_value = cache->LookupOrCreate(key);

  EXPECT_EQ(cache_value.compile_state, DeviceCompileState::kUncompiled);
  EXPECT_EQ(cache_value.request_count, 1);
  EXPECT_EQ(cache_value.compilation_result, nullptr);
  EXPECT_EQ(cache_value.executable, nullptr);
}

TEST(DeviceCompilationCacheTest, IncrementRequestCountOnLookup) {

  EXPECT_EQ(arg_node->op_def().name(), "_Arg");
  EXPECT_EQ(arg_node->attrs().FindByString("T")->type(), DT_FLOAT);

  const Node* retval_node = node_name_index.at("_retval0");
  EXPECT_EQ(retval_node->op_def().name(), "_Retval");
  EXPECT_EQ(retval_node->attrs().FindByString("T")->type(), DT_FLOAT);

  EXPECT_EQ(identity_node->num_outputs(), 1);
  EXPECT_EQ(retval_node->num_inputs(), 1);
  const Node* retval_input_node = nullptr;

  // verify transpose
  EXPECT_EQ(
      fused_lstm_func_->getAttrOfType<StringAttr>(kTFImplements).getValue(),
      convert.GetCompositeOpName());
  EXPECT_EQ(fused_lstm_func_.getNumArguments(), 5);
  EXPECT_EQ(fused_lstm_func_.getFunctionType().getNumResults(), 1);

  auto transpose_op = fused_lstm_func_.getBody().front().begin();
  transpose_op++;

  foo.Set(String("b"), Integer(33));
  EXPECT_EQ(foo.Get<Integer>(String("b"))->get(), 33);
}

TEST(ObjectTest, TestTuple) {
  Tuple foo(String("a"), Integer(33), Float(10.f));
  EXPECT_EQ(foo.size(), 3);
  EXPECT_EQ(foo.Get<Integer>(1)->get(), 33);
}

TEST(ObjectTest, TestList) {
  List l;
  EXPECT_EQ(l.size(), 0);
  l.append(Integer(3));
  EXPECT_EQ(l.Get<Integer>(0)->get(), 3);
  EXPECT_EQ(l.size(), 1);
}

                throw new CIFSException("Failed to decrypt MIC", e);
            }
        }

        int expectSeq = this.verifySequence.getAndIncrement();
        if ( expectSeq != seq ) {
            throw new CIFSException(String.format("Invalid MIC sequence, expect %d have %d", expectSeq, seq));
        }

        byte[] verify = new byte[8];
        System.arraycopy(mic, 4, verify, 0, 8);

  auto context = CreateContext();

  EXPECT_EQ(ToBfloat16Type(Float8E4M3FNType::get(context.get())),
            Float8E4M3FNType::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(Float16Type::get(context.get())),
            Float16Type::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(BFloat16Type::get(context.get())),
            BFloat16Type::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(Float32Type::get(context.get())),

  EXPECT_EQ(0, TF_ShapeDims(shape_a));

  const TF_SignatureDefParam* param_b = TF_SignatureDefParamListGet(args, 1);
  const TF_TensorSpec* tensor_spec_b = TF_SignatureDefParamTensorSpec(param_b);
  const TF_Shape* shape_b = TF_TensorSpecShape(tensor_spec_b);

  // Input "b" is a scalar, float32 tensor
  EXPECT_EQ("b", std::string(TF_SignatureDefParamName(param_b)));

      // expected-remark@above {{ID: 8}}
      // expected-remark@above {{Predecessors: {5,6}}}
      // expected-remark@above {{Successors: {9}}}
      tf_executor.yield
      // expected-remark@above {{ID: 9}}
      // expected-remark@above {{Predecessors: {7,8}}}
    }
    tf_executor.fetch %island : !tf_executor.control
    // expected-remark@above {{ID: 11}}
    // expected-remark@above {{Predecessors: {10}}}
  }

  { CU_assertImplementation(((actual) == (expected)), __LINE__, ("CU_ASSERT_EQUAL_FATAL(" #actual "," #expected ")"), __FILE__, "", CU_TRUE); }

/** Asserts that actual != expected.
 *  Reports failure with no other action.
 */
#define CU_ASSERT_NOT_EQUAL(actual, expected) \
  { CU_assertImplementation(((actual) != (expected)), __LINE__, ("CU_ASSERT_NOT_EQUAL(" #actual "," #expected ")"), __FILE__, "", CU_FALSE); }

        versions: [EMPTY, FIXED_12],
        expected: "12"
    ).and(
        versions: [EMPTY, PREFER_12],
        expected: "12"
    ).and(
        versions: [EMPTY, RANGE_10_12],
        expected: "12"
    ).and(
        versions: [EMPTY, EMPTY],
        expected: ""
    ).and(
        versions: [EMPTY, EMPTY, FIXED_12],
        expected: "12"
    )