chromium/v8/test/unittests/compiler/common-operator-unittest.cc

// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <limits>

#include "src/compiler/common-operator.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"
#include "src/compiler/operator-properties.h"
#include "test/unittests/test-utils.h"

namespace v8 {
namespace internal {
namespace compiler {
namespace common_operator_unittest {

// -----------------------------------------------------------------------------
// Shared operators.


namespace {

struct SharedOperator { … };


std::ostream& operator<<(std::ostream& os, const SharedOperator& fop) { … }

const SharedOperator kSharedOperators[] = …;


class CommonSharedOperatorTest
    : public TestWithZone,
      public ::testing::WithParamInterface<SharedOperator> { … };


TEST_P(CommonSharedOperatorTest, InstancesAreGloballyShared) { … }


TEST_P(CommonSharedOperatorTest, NumberOfInputsAndOutputs) { … }


TEST_P(CommonSharedOperatorTest, OpcodeIsCorrect) { … }


TEST_P(CommonSharedOperatorTest, Properties) { … }

INSTANTIATE_TEST_SUITE_P(…);

// -----------------------------------------------------------------------------
// Other operators.


namespace {

class CommonOperatorTest : public TestWithZone { … };


const int kArguments[] = …;


const size_t kCases[] = …;


const float kFloatValues[] = {-std::numeric_limits<float>::infinity(),
                              std::numeric_limits<float>::min(),
                              -1.0f,
                              -0.0f,
                              0.0f,
                              1.0f,
                              std::numeric_limits<float>::max(),
                              std::numeric_limits<float>::infinity(),
                              std::numeric_limits<float>::quiet_NaN(),
                              std::numeric_limits<float>::signaling_NaN()};


const size_t kInputCounts[] = …;


const int32_t kInt32Values[] = …;


const BranchHint kBranchHints[] = …;

}  // namespace


TEST_F(CommonOperatorTest, End) { … }


TEST_F(CommonOperatorTest, Return) { … }


TEST_F(CommonOperatorTest, Branch) { … }


TEST_F(CommonOperatorTest, Switch) { … }


TEST_F(CommonOperatorTest, IfValue) { … }


TEST_F(CommonOperatorTest, Select) { … }


TEST_F(CommonOperatorTest, Float32Constant) { … }


TEST_F(CommonOperatorTest, Float64Constant) { … }


TEST_F(CommonOperatorTest, NumberConstant) { … }


TEST_F(CommonOperatorTest, BeginRegion) { … }

TEST_F(CommonOperatorTest, FinishRegion) { … }

TEST_F(CommonOperatorTest, Projection) { … }

}  // namespace
}  // namespace common_operator_unittest
}  // namespace compiler
}  // namespace internal
}  // namespace v8