| /* Copyright 2015 The TensorFlow Authors. All Rights Reserved. |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ==============================================================================*/ |
| |
| #include "tensorflow/core/framework/fake_input.h" |
| #include "tensorflow/core/framework/node_def_builder.h" |
| #include "tensorflow/core/framework/tensor.h" |
| #include "tensorflow/core/framework/tensor_testutil.h" |
| #include "tensorflow/core/kernels/ops_testutil.h" |
| #include "tensorflow/core/kernels/ops_util.h" |
| #include "tensorflow/core/platform/test.h" |
| |
| namespace tensorflow { |
| namespace { |
| |
| // Tests for the switch op |
| class SwitchOpTest : public OpsTestBase { |
| protected: |
| void Initialize(DataType dt) { |
| TF_ASSERT_OK(NodeDefBuilder("op", "Switch") |
| .Input(FakeInput(dt)) |
| .Input(FakeInput()) |
| .Finalize(node_def())); |
| TF_ASSERT_OK(InitOp()); |
| } |
| }; |
| |
| TEST_F(SwitchOpTest, Int32Success_6_s0) { |
| Initialize(DT_INT32); |
| AddInputFromArray<int32>(TensorShape({6}), {1, 2, 3, 4, 5, 6}); |
| AddInputFromArray<bool>(TensorShape({}), {false}); |
| TF_ASSERT_OK(RunOpKernel()); |
| Tensor expected(allocator(), DT_INT32, TensorShape({6})); |
| test::FillValues<int32>(&expected, {1, 2, 3, 4, 5, 6}); |
| test::ExpectTensorEqual<int32>(expected, *GetOutput(0)); |
| EXPECT_EQ(nullptr, GetOutput(1)); |
| } |
| |
| TEST_F(SwitchOpTest, Int32Success_6_s1) { |
| Initialize(DT_INT32); |
| AddInputFromArray<int32>(TensorShape({6}), {1, 2, 3, 4, 5, 6}); |
| AddInputFromArray<bool>(TensorShape({}), {true}); |
| TF_ASSERT_OK(RunOpKernel()); |
| Tensor expected(allocator(), DT_INT32, TensorShape({6})); |
| test::FillValues<int32>(&expected, {1, 2, 3, 4, 5, 6}); |
| test::ExpectTensorEqual<int32>(expected, *GetOutput(1)); |
| EXPECT_EQ(nullptr, GetOutput(0)); |
| } |
| |
| TEST_F(SwitchOpTest, Int32Success_2_3_s0) { |
| Initialize(DT_INT32); |
| AddInputFromArray<int32>(TensorShape({2, 3}), {1, 2, 3, 4, 5, 6}); |
| AddInputFromArray<bool>(TensorShape({}), {false}); |
| TF_ASSERT_OK(RunOpKernel()); |
| Tensor expected(allocator(), DT_INT32, TensorShape({2, 3})); |
| test::FillValues<int32>(&expected, {1, 2, 3, 4, 5, 6}); |
| test::ExpectTensorEqual<int32>(expected, *GetOutput(0)); |
| EXPECT_EQ(nullptr, GetOutput(1)); |
| } |
| |
| TEST_F(SwitchOpTest, StringSuccess_s1) { |
| Initialize(DT_STRING); |
| AddInputFromArray<string>(TensorShape({6}), {"A", "b", "C", "d", "E", "f"}); |
| AddInputFromArray<bool>(TensorShape({}), {true}); |
| TF_ASSERT_OK(RunOpKernel()); |
| Tensor expected(allocator(), DT_STRING, TensorShape({6})); |
| test::FillValues<string>(&expected, {"A", "b", "C", "d", "E", "f"}); |
| test::ExpectTensorEqual<string>(expected, *GetOutput(1)); |
| EXPECT_EQ(nullptr, GetOutput(0)); |
| } |
| |
| class AbortOpTest : public OpsTestBase { |
| protected: |
| }; |
| |
| #ifdef PLATFORM_WINDOWS |
| #define SIGABRT 3 |
| |
| class KilledBySignal { |
| public: |
| explicit KilledBySignal(int signum) : signum_(signum) {} |
| bool operator()(int exit_status) const { return exit_status == signum_; } |
| |
| private: |
| const int signum_; |
| }; |
| #else |
| #define KilledBySignal ::testing::KilledBySignal |
| #endif |
| |
| // Pass an error message to the op. |
| TEST_F(AbortOpTest, pass_error_msg) { |
| TF_ASSERT_OK(NodeDefBuilder("abort_op", "Abort") |
| .Attr("error_msg", "abort_op_test") |
| .Finalize(node_def())); |
| TF_ASSERT_OK(InitOp()); |
| EXPECT_EXIT(RunOpKernel().IgnoreError(), KilledBySignal(SIGABRT), |
| "Abort_op intentional failure; abort_op_test"); |
| } |
| |
| // Use the default error message. |
| TEST_F(AbortOpTest, default_msg) { |
| TF_ASSERT_OK(NodeDefBuilder("abort_op", "Abort").Finalize(node_def())); |
| TF_ASSERT_OK(InitOp()); |
| EXPECT_EXIT(RunOpKernel().IgnoreError(), KilledBySignal(SIGABRT), |
| "Abort_op intentional failure; "); |
| } |
| |
| // Exit normally. |
| TEST_F(AbortOpTest, exit_normally) { |
| TF_ASSERT_OK(NodeDefBuilder("abort_op", "Abort") |
| .Attr("exit_without_error", true) |
| .Finalize(node_def())); |
| TF_ASSERT_OK(InitOp()); |
| EXPECT_EXIT(RunOpKernel().IgnoreError(), ::testing::ExitedWithCode(0), ""); |
| } |
| |
| } // namespace |
| } // namespace tensorflow |