experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make TensorValue constructor explicit

Browse Source 
PiperOrigin-RevId: 250684642
This commit is contained in:
Gaurav Jain 2019-05-30 07:31:11 -07:00 committed by TensorFlower Gardener
parent fac9d70abf
commit ef0b1eff8d
20 changed files with 380 additions and 259 deletions

2
tensorflow/core/common_runtime/collective_util.cc
View File

@ -82,7 +82,7 @@ string SubdivPermDebugString(const CollectiveParams& col_params) {
SubContext::SubContext(OpKernelContext* ctx, OpKernelContext::Params* params,
OpKernel* op, Tensor* output, Tensor* input)
: sub_params_(*params),
sub_inputs_({output, input}),
sub_inputs_({TensorValue(output), TensorValue(input)}),
sub_input_attr_({ctx->input_alloc_attr(0), ctx->input_alloc_attr(0)}),
sub_input_dc_(
{ctx->input_device_context(0), ctx->input_device_context(0)}) {

3
tensorflow/core/framework/op_kernel.h
View File

@ -533,8 +533,7 @@ class OpOutputList {
// a mutex to prevent concurrent access to the tensor.
struct TensorValue {
TensorValue() : mutex_if_ref(nullptr), tensor(nullptr) {}
TensorValue(Tensor* t) // NOLINT(runtime/explicit)
: mutex_if_ref(nullptr), tensor(t) {}
explicit TensorValue(Tensor* t) : mutex_if_ref(nullptr), tensor(t) {}
TensorValue(mutex* mu, Tensor* t) : mutex_if_ref(mu), tensor(t) {}
Tensor* operator->() const { return tensor; }
bool is_ref() const { return mutex_if_ref != nullptr; }

2
tensorflow/core/grappler/optimizers/remapper.cc
View File

@ -992,7 +992,7 @@ void AddBatchNormNodes(const FusedBatchNorm& matched,
value.scalar<float>()() = epsilon;
NodeDef* variance_epsilon = optimized_graph->add_node();
TF_CHECK_OK(ConstantFolding::CreateNodeDef(
AddPrefixToNodeName("Const", fused_node.name()), &value,
AddPrefixToNodeName("Const", fused_node.name()), TensorValue(&value),
variance_epsilon));
variance_epsilon->set_device(fused_node.device());

60
tensorflow/core/kernels/data/batch_dataset_op_test.cc
View File

@ -236,8 +236,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, GetNext) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -289,8 +290,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, DatasetNodeName) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -323,8 +325,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, DatasetTypeString) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -357,8 +360,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, DatasetOutputDtypes) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -392,8 +396,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, DatasetOutputShapes) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -427,8 +432,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, Cardinality) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -461,8 +467,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, DatasetSave) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -500,8 +507,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, IteratorOutputDtypes) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -542,8 +550,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, IteratorOutputShapes) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -584,8 +593,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, IteratorOutputPrefix) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -625,8 +635,9 @@ TEST_P(ParameterizedBatchDatasetOpTest, Roundtrip) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));
@ -702,8 +713,9 @@ TEST_F(BatchDatasetOpTest, InvalidBatchSize) {
Tensor batch_size = test_case.batch_size;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs{&range_dataset_tensor, &batch_size,
&drop_remainder};
gtl::InlinedVector<TensorValue, 4> inputs{TensorValue(&range_dataset_tensor),
TensorValue(&batch_size),
TensorValue(&drop_remainder)};
std::unique_ptr<OpKernelContext> batch_dataset_context;
TF_ASSERT_OK(CreateBatchDatasetContext(batch_dataset_kernel.get(), &inputs,
&batch_dataset_context));

36
tensorflow/core/kernels/data/filter_dataset_op_test.cc
View File

@ -178,7 +178,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, GetNext) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -221,7 +222,8 @@ TEST_F(FilterDatasetOpTest, DatasetNodeName) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -248,7 +250,8 @@ TEST_F(FilterDatasetOpTest, DatasetTypeString) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -276,7 +279,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, DatasetOutputDtypes) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -304,7 +308,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, DatasetOutputShapes) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -332,7 +337,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, Cardinality) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -359,7 +365,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, DatasetSave) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -391,7 +398,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, IteratorOutputDtypes) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -426,7 +434,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, IteratorOutputShapes) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -461,7 +470,8 @@ TEST_F(ParameterizedFilterDatasetOpTest, IteratorOutputPrefix) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -496,7 +506,8 @@ TEST_P(ParameterizedFilterDatasetOpTest, Roundtrip) {
std::vector<Tensor> inputs_for_tensor_slice_dataset = test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(), &inputs,
&filter_dataset_context));
@ -565,7 +576,8 @@ TEST_F(ParameterizedFilterDatasetOpTest, InvalidFuncs) {
test_case.input_tensors;
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(
&inputs_for_tensor_slice_dataset, &tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> filter_dataset_context;
TF_ASSERT_OK(CreateFilterDatasetContext(filter_dataset_kernel.get(),
&inputs, &filter_dataset_context));

36
tensorflow/core/kernels/data/flat_map_dataset_op_test.cc
View File

@ -136,7 +136,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, GetNext) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -185,7 +186,8 @@ TEST_F(FlatMapDatasetOpTest, InvalidFunc) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -225,7 +227,8 @@ TEST_F(FlatMapDatasetOpTest, DatasetNodeName) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -254,7 +257,8 @@ TEST_F(FlatMapDatasetOpTest, DatasetTypeString) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -284,7 +288,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, DatasetOutputDtypes) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -314,7 +319,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, DatasetOutputShapes) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -344,7 +350,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, Cardinality) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -373,7 +380,8 @@ TEST_F(FlatMapDatasetOpTest, DatasetSave) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -407,7 +415,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, IteratorOutputDtypes) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -444,7 +453,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, IteratorOutputShapes) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -481,7 +491,8 @@ TEST_F(FlatMapDatasetOpTest, IteratorOutputPrefix) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));
@ -519,7 +530,8 @@ TEST_P(ParameterizedFlatMapDatasetOpTest, Roundtrip) {
TF_ASSERT_OK(CreateTensorSliceDatasetTensor(&inputs_for_tensor_slice_dataset,
&tensor_slice_dataset_tensor));
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor)});
std::unique_ptr<OpKernelContext> flat_map_dataset_context;
TF_ASSERT_OK(CreateFlatMapDatasetContext(flat_map_dataset_kernel.get(),
&inputs, &flat_map_dataset_context));

39
tensorflow/core/kernels/data/interleave_dataset_op_test.cc
View File

@ -314,7 +314,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, GetNext) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -365,7 +366,8 @@ TEST_F(InterleaveDatasetOpTest, InvalidCycleLength) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -394,7 +396,8 @@ TEST_F(InterleaveDatasetOpTest, InvalidBlockLength) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -423,7 +426,8 @@ TEST_F(InterleaveDatasetOpTest, DatasetNodeName) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -454,7 +458,8 @@ TEST_F(InterleaveDatasetOpTest, DatasetTypeString) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -485,7 +490,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, DatasetOutputDtypes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -517,7 +523,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, DatasetOutputShapes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -549,7 +556,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, Cardinality) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -580,7 +588,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, DatasetSave) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -616,7 +625,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, IteratorOutputDtypes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -655,7 +665,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, IteratorOutputShapes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -694,7 +705,8 @@ TEST_F(InterleaveDatasetOpTest, IteratorOutputPrefix) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));
@ -732,7 +744,8 @@ TEST_P(ParameterizedInterleaveDatasetOpTest, Roundtrip) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
gtl::InlinedVector<TensorValue, 4> inputs(
{&tensor_slice_dataset_tensor, &cycle_length, &block_length});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length)});
std::unique_ptr<OpKernelContext> interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
interleave_dataset_kernel.get(), &inputs, &interleave_dataset_context));

28
tensorflow/core/kernels/data/padded_batch_dataset_op_test.cc
View File

@ -560,7 +560,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, GetNext) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -618,7 +618,7 @@ TEST_F(PaddedBatchDatasetOpTest, DatasetNodeName) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -660,7 +660,7 @@ TEST_F(PaddedBatchDatasetOpTest, DatasetTypeString) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -702,7 +702,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, DatasetOutputDtypes) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -745,7 +745,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, DatasetOutputShapes) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -788,7 +788,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, Cardinality) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -831,7 +831,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, DatasetSave) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -878,7 +878,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, IteratorOutputDtypes) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -928,7 +928,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, IteratorOutputShapes) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -978,7 +978,7 @@ TEST_F(PaddedBatchDatasetOpTest, IteratorOutputPrefix) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -1027,7 +1027,7 @@ TEST_P(ParameterizedPaddedBatchDatasetOpTest, Roundtrip) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -1109,7 +1109,7 @@ TEST_F(PaddedBatchDatasetOpTest, ShortPadding) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -1162,7 +1162,7 @@ TEST_F(PaddedBatchDatasetOpTest, InvalidPaddedShapes) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}
@ -1219,7 +1219,7 @@ TEST_F(PaddedBatchDatasetOpTest, InvalidArguments) {
std::vector<Tensor> padding_values = test_case.padding_values;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&concatenate_dataset_tensor, &batch_size});
{TensorValue(&concatenate_dataset_tensor), TensorValue(&batch_size)});
for (auto &padded_shape : padded_shapes) {
inputs.emplace_back(&padded_shape);
}

72
tensorflow/core/kernels/data/parallel_interleave_dataset_op_test.cc
View File

@ -465,9 +465,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, GetNext) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -520,9 +520,9 @@ TEST_F(ParallelInterleaveDatasetOpTest, InvalidArguments) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -555,9 +555,9 @@ TEST_F(ParallelInterleaveDatasetOpTest, DatasetNodeName) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -590,9 +590,9 @@ TEST_F(ParallelInterleaveDatasetOpTest, DatasetTypeString) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -625,9 +625,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, DatasetOutputDtypes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -661,9 +661,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, DatasetOutputShapes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -698,9 +698,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, Cardinality) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -734,9 +734,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, DatasetSave) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -775,9 +775,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, IteratorOutputDtypes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -818,9 +818,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, IteratorOutputShapes) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -861,9 +861,9 @@ TEST_F(ParallelInterleaveDatasetOpTest, IteratorOutputPrefix) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,
@ -903,9 +903,9 @@ TEST_P(ParameterizedParallelInterleaveDatasetOpTest, Roundtrip) {
Tensor cycle_length = test_case.cycle_length;
Tensor block_length = test_case.block_length;
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> inputs({&tensor_slice_dataset_tensor,
&cycle_length, &block_length,
&num_parallel_calls});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&cycle_length),
TensorValue(&block_length), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_interleave_dataset_context;
TF_ASSERT_OK(CreateInterleaveDatasetContext(
parallel_interleave_dataset_kernel.get(), &inputs,

24
tensorflow/core/kernels/data/parallel_map_dataset_op_test.cc
View File

@ -305,7 +305,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, GetNext) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -359,7 +359,7 @@ TEST_F(ParallelMapDatasetOpTest, DatasetNodeName) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -396,7 +396,7 @@ TEST_F(ParallelMapDatasetOpTest, DatasetTypeString) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -433,7 +433,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, DatasetOutputDtypes) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -471,7 +471,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, DatasetOutputShapes) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -509,7 +509,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, Cardinality) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -547,7 +547,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, DatasetSave) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -590,7 +590,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, IteratorOutputDtypes) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -635,7 +635,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, IteratorOutputShapes) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -680,7 +680,7 @@ TEST_F(ParallelMapDatasetOpTest, IteratorOutputPrefix) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -724,7 +724,7 @@ TEST_P(ParameterizedParallelMapDatasetOpTest, Roundtrip) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(
@ -794,7 +794,7 @@ TEST_F(ParallelMapDatasetOpTest, InvalidNumParallelCalls) {
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
Tensor num_parallel_calls = test_case.num_parallel_calls;
gtl::InlinedVector<TensorValue, 4> parallel_map_dataset_inputs(
{&range_dataset_tensor, &num_parallel_calls});
{TensorValue(&range_dataset_tensor), TensorValue(&num_parallel_calls)});
std::unique_ptr<OpKernelContext> parallel_map_dataset_context;
TF_ASSERT_OK(CreateParallelMapDatasetContext(

24
tensorflow/core/kernels/data/prefetch_dataset_op_test.cc
View File

@ -164,7 +164,7 @@ TEST_P(ParameterizedPrefetchDatasetOpTest, GetNext) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -217,7 +217,7 @@ TEST_F(PrefetchDatasetOpTest, InvalidBufferSize) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -247,7 +247,7 @@ TEST_F(PrefetchDatasetOpTest, DatasetNodeName) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -279,7 +279,7 @@ TEST_F(PrefetchDatasetOpTest, DatasetTypeString) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -312,7 +312,7 @@ TEST_F(PrefetchDatasetOpTest, DatasetOutputDtypes) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -345,7 +345,7 @@ TEST_F(PrefetchDatasetOpTest, DatasetOutputShapes) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -378,7 +378,7 @@ TEST_P(ParameterizedPrefetchDatasetOpTest, Cardinality) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -410,7 +410,7 @@ TEST_F(PrefetchDatasetOpTest, DatasetSave) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -447,7 +447,7 @@ TEST_F(PrefetchDatasetOpTest, IteratorOutputDtypes) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -487,7 +487,7 @@ TEST_F(PrefetchDatasetOpTest, IteratorOutputShapes) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -527,7 +527,7 @@ TEST_F(PrefetchDatasetOpTest, IteratorOutputPrefix) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,
@ -568,7 +568,7 @@ TEST_P(ParameterizedPrefetchDatasetOpTest, Roundtrip) {
Tensor buffer_size =
CreateTensor<int64>(TensorShape{}, {test_case.buffer_size});
gtl::InlinedVector<TensorValue, 4> inputs_for_prefetch_dataset(
{&tensor_slice_dataset_tensor, &buffer_size});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&buffer_size)});
std::unique_ptr<OpKernel> prefetch_dataset_kernel;
TF_ASSERT_OK(CreatePrefetchDatasetKernel(test_case.expected_output_dtypes,

36
tensorflow/core/kernels/data/range_dataset_op_test.cc
View File

@ -102,7 +102,8 @@ TEST_P(ParameterizedRangeDatasetOpTest, GetNext) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -146,7 +147,8 @@ TEST_F(RangeDatasetOpTest, ZeroStep) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -170,7 +172,8 @@ TEST_F(RangeDatasetOpTest, DatasetNodeName) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -195,7 +198,8 @@ TEST_F(RangeDatasetOpTest, DatasetTypeString) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -221,7 +225,8 @@ TEST_F(RangeDatasetOpTest, DatasetOutputDtypes) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -247,7 +252,8 @@ TEST_F(RangeDatasetOpTest, DatasetOutputShapes) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -273,7 +279,8 @@ TEST_P(ParameterizedRangeDatasetOpTest, Cardinality) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -298,7 +305,8 @@ TEST_F(RangeDatasetOpTest, DatasetSave) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -329,7 +337,8 @@ TEST_F(RangeDatasetOpTest, IteratorOutputDtypes) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -362,7 +371,8 @@ TEST_F(RangeDatasetOpTest, IteratorOutputShapes) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -395,7 +405,8 @@ TEST_F(RangeDatasetOpTest, IteratorOutputPrefix) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(
@ -428,7 +439,8 @@ TEST_P(ParameterizedRangeDatasetOpTest, Roundtrip) {
Tensor start = CreateTensor<int64>(TensorShape({}), {test_case.start});
Tensor stop = CreateTensor<int64>(TensorShape({}), {test_case.stop});
Tensor step = CreateTensor<int64>(TensorShape({}), {test_case.step});
gtl::InlinedVector<TensorValue, 4> inputs({&start, &stop, &step});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&start), TensorValue(&stop), TensorValue(&step)});
std::unique_ptr<OpKernel> range_dataset_kernel;
TF_ASSERT_OK(

3
tensorflow/core/kernels/data/reduce_dataset_op_test.cc
View File

@ -154,7 +154,8 @@ TEST_P(ParameterizedReduceDatasetOpTest, Compute) {
TF_ASSERT_OK(
StoreDatasetInVariantTensor(range_dataset, &range_dataset_tensor));
std::vector<Tensor> initial_state = test_case.initial_state;
gtl::InlinedVector<TensorValue, 4> inputs({&range_dataset_tensor});
gtl::InlinedVector<TensorValue, 4> inputs(
{TensorValue(&range_dataset_tensor)});
for (auto &t : initial_state) {
inputs.emplace_back(&t);
}

63
tensorflow/core/kernels/data/shard_dataset_op_test.cc
View File

@ -278,8 +278,9 @@ TEST_P(ParameterizedShardDatasetOpTest, GetNext) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -332,8 +333,9 @@ TEST_F(ShardDatasetOpTest, DatasetNodeName) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -367,8 +369,9 @@ TEST_F(ShardDatasetOpTest, DatasetTypeString) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -402,8 +405,9 @@ TEST_P(ParameterizedShardDatasetOpTest, DatasetOutputDtypes) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -438,8 +442,9 @@ TEST_P(ParameterizedShardDatasetOpTest, DatasetOutputShapes) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -474,8 +479,9 @@ TEST_P(ParameterizedShardDatasetOpTest, Cardinality) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -509,8 +515,9 @@ TEST_P(ParameterizedShardDatasetOpTest, DatasetSave) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -549,8 +556,9 @@ TEST_P(ParameterizedShardDatasetOpTest, IteratorOutputDtypes) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -592,8 +600,9 @@ TEST_P(ParameterizedShardDatasetOpTest, IteratorOutputShapes) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -635,8 +644,9 @@ TEST_F(ShardDatasetOpTest, IteratorOutputPrefix) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -677,8 +687,9 @@ TEST_P(ParameterizedShardDatasetOpTest, Roundtrip) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -755,7 +766,8 @@ TEST_F(ShardDatasetOpTest, InvalidArguments) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
{TensorValue(&range_dataset_tensor), TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));
@ -789,8 +801,9 @@ TEST_F(ShardDatasetOpTest, NoElemForEachShard) {
Tensor num_shards = test_case.num_shards;
Tensor index = test_case.index;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &num_shards, &index});
gtl::InlinedVector<TensorValue, 4> inputs({TensorValue(&range_dataset_tensor),
TensorValue(&num_shards),
TensorValue(&index)});
std::unique_ptr<OpKernelContext> shard_dataset_context;
TF_ASSERT_OK(CreateShardDatasetContext(shard_dataset_kernel.get(), &inputs,
&shard_dataset_context));

60
tensorflow/core/kernels/data/shuffle_dataset_op_test.cc
View File

@ -339,8 +339,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, GetNext) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -424,8 +425,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, DatasetNodeName) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -467,8 +469,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, DatasetTypeString) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -510,8 +513,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, DatasetOutputDtypes) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -550,8 +554,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, DatasetOutputShapes) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -590,8 +595,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, Cardinality) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -629,8 +635,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, DatasetSave) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -673,8 +680,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, IteratorOutputDtypes) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -719,8 +727,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, IteratorOutputShapes) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -765,8 +774,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, IteratorOutputPrefix) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -814,8 +824,9 @@ TEST_P(ParameterizedShuffleDatasetOpTest, Roundtrip) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(
@ -896,8 +907,9 @@ TEST_F(ShuffleDatasetOpTest, InvalidArguments) {
Tensor seed = test_case.seed;
Tensor seed2 = test_case.seed2;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &buffer_size, &seed, &seed2});
if (count_value != 1) inputs.push_back(&count);
{TensorValue(&range_dataset_tensor), TensorValue(&buffer_size),
TensorValue(&seed), TensorValue(&seed2)});
if (count_value != 1) inputs.push_back(TensorValue(&count));
std::unique_ptr<OpKernelContext> dataset_context;
TF_ASSERT_OK(

22
tensorflow/core/kernels/data/skip_dataset_op_test.cc
View File

@ -162,7 +162,7 @@ TEST_P(ParameterizedSkipDatasetOpTest, GetNext) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -213,7 +213,7 @@ TEST_F(SkipDatasetOpTest, DatasetNodeName) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -243,7 +243,7 @@ TEST_F(SkipDatasetOpTest, DatasetTypeString) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -273,7 +273,7 @@ TEST_F(SkipDatasetOpTest, DatasetOutputDtypes) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -304,7 +304,7 @@ TEST_F(SkipDatasetOpTest, DatasetOutputShapes) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -335,7 +335,7 @@ TEST_P(ParameterizedSkipDatasetOpTest, Cardinality) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -365,7 +365,7 @@ TEST_F(SkipDatasetOpTest, DatasetSave) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -400,7 +400,7 @@ TEST_P(ParameterizedSkipDatasetOpTest, IteratorOutputDtypes) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -438,7 +438,7 @@ TEST_P(ParameterizedSkipDatasetOpTest, IteratorOutputShapes) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -476,7 +476,7 @@ TEST_P(ParameterizedSkipDatasetOpTest, IteratorOutputPrefix) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,
@ -517,7 +517,7 @@ TEST_P(ParameterizedSkipDatasetOpTest, Roundtrip) {
&tensor_slice_dataset_tensor));
Tensor count = CreateTensor<int64>(TensorShape{}, {test_case.count});
gtl::InlinedVector<TensorValue, 4> inputs_for_skip_dataset(
{&tensor_slice_dataset_tensor, &count});
{TensorValue(&tensor_slice_dataset_tensor), TensorValue(&count)});
std::unique_ptr<OpKernel> skip_dataset_kernel;
TF_ASSERT_OK(CreateSkipDatasetKernel(test_case.expected_output_dtypes,

55
tensorflow/core/kernels/data/sparse_tensor_slice_dataset_op_test.cc
View File

@ -154,8 +154,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, GetNext) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -199,8 +200,9 @@ TEST_F(SparseTensorSliceDatasetOpTest, DatasetNodeName) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -225,8 +227,9 @@ TEST_F(SparseTensorSliceDatasetOpTest, DatasetTypeString) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -251,8 +254,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, DatasetOutputDtypes) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -281,8 +285,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, DatasetOutputShapes) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -311,8 +316,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, Cardinality) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -337,8 +343,9 @@ TEST_F(SparseTensorSliceDatasetOpTest, DatasetSave) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -368,8 +375,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, IteratorOutputDtypes) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -403,8 +411,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, IteratorOutputShapes) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -438,8 +447,9 @@ TEST_F(SparseTensorSliceDatasetOpTest, IteratorOutputPrefix) {
std::vector<SparseTensorParam> expected_outputs = test_case.expected_outputs;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));
@ -470,8 +480,9 @@ TEST_P(ParameterizedSparseTensorSliceDatasetOpTest, Roundtrip) {
std::vector<int> breakpoints = test_case.breakpoints;
DataType tvalues = input_sparse_tensor.values.dtype();
gtl::InlinedVector<TensorValue, 4> inputs = {
&input_sparse_tensor.indices, &input_sparse_tensor.values,
&input_sparse_tensor.dense_shape};
TensorValue(&input_sparse_tensor.indices),
TensorValue(&input_sparse_tensor.values),
TensorValue(&input_sparse_tensor.dense_shape)};
std::unique_ptr<OpKernel> dataset_kernel;
TF_ASSERT_OK(CreateSparseTensorSliceDatasetKernel(tvalues, &dataset_kernel));

22
tensorflow/core/kernels/data/tensor_dataset_op_test.cc
View File

@ -140,7 +140,7 @@ TEST_P(ParametrizedTensorDatasetOpTest, GetNext) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -190,7 +190,7 @@ TEST_F(TensorDatasetOpTest, DatasetTypeString) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -216,7 +216,7 @@ TEST_F(TensorDatasetOpTest, DatasetNodeName) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -242,7 +242,7 @@ TEST_F(TensorDatasetOpTest, DatasetOutputDtypes) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -268,7 +268,7 @@ TEST_F(TensorDatasetOpTest, DatasetOutputShapes) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -299,7 +299,7 @@ TEST_F(TensorDatasetOpTest, Cardinality) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -325,7 +325,7 @@ TEST_P(ParametrizedTensorDatasetOpTest, DatasetSave) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -356,7 +356,7 @@ TEST_P(ParametrizedTensorDatasetOpTest, IteratorOutputDtypes) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -388,7 +388,7 @@ TEST_P(ParametrizedTensorDatasetOpTest, IteratorOutputShapes) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -426,7 +426,7 @@ TEST_F(TensorDatasetOpTest, IteratorOutputPrefix) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,
@ -459,7 +459,7 @@ TEST_P(ParametrizedTensorDatasetOpTest, Roundtrip) {
std::vector<Tensor> components = test_case.components;
gtl::InlinedVector<TensorValue, 4> inputs;
for (auto &component : components) {
inputs.push_back(&component);
inputs.push_back(TensorValue(&component));
}
std::unique_ptr<OpKernel> tensor_dataset_kernel;
TF_ASSERT_OK(CreateTensorDatasetKernel(test_case.expected_output_dtypes,

48
tensorflow/core/kernels/data/window_dataset_op_test.cc
View File

@ -336,7 +336,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, GetNext) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -412,7 +414,9 @@ TEST_F(WindowDatasetOpTest, DatasetNodeName) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -448,7 +452,9 @@ TEST_F(WindowDatasetOpTest, DatasetTypeString) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -484,7 +490,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, DatasetOutputDtypes) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -521,7 +529,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, DatasetOutputShapes) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -558,7 +568,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, Cardinality) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -594,7 +606,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, DatasetSave) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -635,7 +649,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, IteratorOutputDtypes) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -679,7 +695,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, IteratorOutputShapes) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -723,7 +741,9 @@ TEST_F(WindowDatasetOpTest, IteratorOutputPrefix) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -766,7 +786,9 @@ TEST_P(ParameterizedWindowDatasetOpTest, Roundtrip) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(), &inputs,
@ -865,7 +887,9 @@ TEST_F(WindowDatasetOpTest, InvalidArguments) {
Tensor stride = test_case.stride;
Tensor drop_remainder = test_case.drop_remainder;
gtl::InlinedVector<TensorValue, 4> inputs(
{&range_dataset_tensor, &size, &shift, &stride, &drop_remainder});
{TensorValue(&range_dataset_tensor), TensorValue(&size),
TensorValue(&shift), TensorValue(&stride),
TensorValue(&drop_remainder)});
std::unique_ptr<OpKernelContext> window_dataset_op_ctx;
TF_ASSERT_OK(CreateWindowDatasetContext(window_dataset_kernel.get(),

4
tensorflow/core/kernels/fingerprint_op_test.cc
View File

@ -48,11 +48,11 @@ class FingerprintOpTest : public OpsTestBase {
TF_RETURN_IF_ERROR(InitOp());
inputs_.clear();
inputs_.push_back(data);
inputs_.push_back(TensorValue(data));
method_ = Tensor(DT_STRING, TensorShape{});
method_.scalar<string>()() = method;
inputs_.push_back(&method_);
inputs_.push_back(TensorValue(&method_));
return Status::OK();
}