/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not read 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 <gtest/gtest.h>

#include "data_type.h"
#include "nodes.h"

namespace art {

// Only runtime types other than void are allowed.
static const DataType::Type kTestTypes[] = {
    DataType::Type::kReference,
    DataType::Type::kBool,
    DataType::Type::kInt8,
    DataType::Type::kUint16,
    DataType::Type::kInt16,
    DataType::Type::kInt32,
    DataType::Type::kInt64,
    DataType::Type::kFloat32,
    DataType::Type::kFloat64,
};

/**
 * Tests for the SideEffects class.
 */

//
// Helper methods.
//

void testWriteAndReadSanity(SideEffects write, SideEffects read) {
  EXPECT_FALSE(write.DoesNothing());
  EXPECT_FALSE(read.DoesNothing());

  EXPECT_TRUE(write.DoesAnyWrite());
  EXPECT_FALSE(write.DoesAnyRead());
  EXPECT_FALSE(read.DoesAnyWrite());
  EXPECT_TRUE(read.DoesAnyRead());

  // All-dependences.
  SideEffects all = SideEffects::All();
  EXPECT_TRUE(all.MayDependOn(write));
  EXPECT_FALSE(write.MayDependOn(all));
  EXPECT_FALSE(all.MayDependOn(read));
  EXPECT_TRUE(read.MayDependOn(all));

  // None-dependences.
  SideEffects none = SideEffects::None();
  EXPECT_FALSE(none.MayDependOn(write));
  EXPECT_FALSE(write.MayDependOn(none));
  EXPECT_FALSE(none.MayDependOn(read));
  EXPECT_FALSE(read.MayDependOn(none));
}

void testWriteAndReadDependence(SideEffects write, SideEffects read) {
  testWriteAndReadSanity(write, read);

  // Dependence only in one direction.
  EXPECT_FALSE(write.MayDependOn(read));
  EXPECT_TRUE(read.MayDependOn(write));
}

void testNoWriteAndReadDependence(SideEffects write, SideEffects read) {
  testWriteAndReadSanity(write, read);

  // No dependence in any direction.
  EXPECT_FALSE(write.MayDependOn(read));
  EXPECT_FALSE(read.MayDependOn(write));
}

//
// Actual tests.
//

TEST(SideEffectsTest, All) {
  SideEffects all = SideEffects::All();
  EXPECT_TRUE(all.DoesAnyWrite());
  EXPECT_TRUE(all.DoesAnyRead());
  EXPECT_FALSE(all.DoesNothing());
  EXPECT_TRUE(all.DoesAllReadWrite());
}

TEST(SideEffectsTest, None) {
  SideEffects none = SideEffects::None();
  EXPECT_FALSE(none.DoesAnyWrite());
  EXPECT_FALSE(none.DoesAnyRead());
  EXPECT_TRUE(none.DoesNothing());
  EXPECT_FALSE(none.DoesAllReadWrite());
}

TEST(SideEffectsTest, DependencesAndNoDependences) {
  // Apply test to each individual data type.
  for (DataType::Type type : kTestTypes) {
    // Same data type and access type: proper write/read dep.
    testWriteAndReadDependence(
        SideEffects::FieldWriteOfType(type, false),
        SideEffects::FieldReadOfType(type, false));
    testWriteAndReadDependence(
        SideEffects::ArrayWriteOfType(type),
        SideEffects::ArrayReadOfType(type));
    // Same data type but different access type: no write/read dep.
    testNoWriteAndReadDependence(
        SideEffects::FieldWriteOfType(type, false),
        SideEffects::ArrayReadOfType(type));
    testNoWriteAndReadDependence(
        SideEffects::ArrayWriteOfType(type),
        SideEffects::FieldReadOfType(type, false));
  }
}

TEST(SideEffectsTest, NoDependences) {
  // Different data type, same access type: no write/read dep.
  testNoWriteAndReadDependence(
      SideEffects::FieldWriteOfType(DataType::Type::kInt32, false),
      SideEffects::FieldReadOfType(DataType::Type::kFloat64, false));
  testNoWriteAndReadDependence(
      SideEffects::ArrayWriteOfType(DataType::Type::kInt32),
      SideEffects::ArrayReadOfType(DataType::Type::kFloat64));
  // Everything different: no write/read dep.
  testNoWriteAndReadDependence(
      SideEffects::FieldWriteOfType(DataType::Type::kInt32, false),
      SideEffects::ArrayReadOfType(DataType::Type::kFloat64));
  testNoWriteAndReadDependence(
      SideEffects::ArrayWriteOfType(DataType::Type::kInt32),
      SideEffects::FieldReadOfType(DataType::Type::kFloat64, false));
}

TEST(SideEffectsTest, VolatileDependences) {
  SideEffects volatile_write =
      SideEffects::FieldWriteOfType(DataType::Type::kInt32, /* is_volatile */ true);
  SideEffects any_write =
      SideEffects::FieldWriteOfType(DataType::Type::kInt32, /* is_volatile */ false);
  SideEffects volatile_read =
      SideEffects::FieldReadOfType(DataType::Type::kInt8, /* is_volatile */ true);
  SideEffects any_read =
      SideEffects::FieldReadOfType(DataType::Type::kInt8, /* is_volatile */ false);

  EXPECT_FALSE(volatile_write.MayDependOn(any_read));
  EXPECT_TRUE(any_read.MayDependOn(volatile_write));
  EXPECT_TRUE(volatile_write.MayDependOn(any_write));
  EXPECT_FALSE(any_write.MayDependOn(volatile_write));

  EXPECT_FALSE(volatile_read.MayDependOn(any_read));
  EXPECT_TRUE(any_read.MayDependOn(volatile_read));
  EXPECT_TRUE(volatile_read.MayDependOn(any_write));
  EXPECT_FALSE(any_write.MayDependOn(volatile_read));
}

TEST(SideEffectsTest, SameWidthTypesNoAlias) {
  // Type I/F.
  testNoWriteAndReadDependence(
      SideEffects::FieldWriteOfType(DataType::Type::kInt32, /* is_volatile */ false),
      SideEffects::FieldReadOfType(DataType::Type::kFloat32, /* is_volatile */ false));
  testNoWriteAndReadDependence(
      SideEffects::ArrayWriteOfType(DataType::Type::kInt32),
      SideEffects::ArrayReadOfType(DataType::Type::kFloat32));
  // Type L/D.
  testNoWriteAndReadDependence(
      SideEffects::FieldWriteOfType(DataType::Type::kInt64, /* is_volatile */ false),
      SideEffects::FieldReadOfType(DataType::Type::kFloat64, /* is_volatile */ false));
  testNoWriteAndReadDependence(
      SideEffects::ArrayWriteOfType(DataType::Type::kInt64),
      SideEffects::ArrayReadOfType(DataType::Type::kFloat64));
}

TEST(SideEffectsTest, AllWritesAndReads) {
  SideEffects s = SideEffects::None();
  // Keep taking the union of different writes and reads.
  for (DataType::Type type : kTestTypes) {
    s = s.Union(SideEffects::FieldWriteOfType(type, /* is_volatile */ false));
    s = s.Union(SideEffects::ArrayWriteOfType(type));
    s = s.Union(SideEffects::FieldReadOfType(type, /* is_volatile */ false));
    s = s.Union(SideEffects::ArrayReadOfType(type));
  }
  EXPECT_TRUE(s.DoesAllReadWrite());
}

TEST(SideEffectsTest, GC) {
  SideEffects can_trigger_gc = SideEffects::CanTriggerGC();
  SideEffects depends_on_gc = SideEffects::DependsOnGC();
  SideEffects all_changes = SideEffects::AllChanges();
  SideEffects all_dependencies = SideEffects::AllDependencies();

  EXPECT_TRUE(depends_on_gc.MayDependOn(can_trigger_gc));
  EXPECT_TRUE(depends_on_gc.Union(can_trigger_gc).MayDependOn(can_trigger_gc));
  EXPECT_FALSE(can_trigger_gc.MayDependOn(depends_on_gc));

  EXPECT_TRUE(depends_on_gc.MayDependOn(all_changes));
  EXPECT_TRUE(depends_on_gc.Union(can_trigger_gc).MayDependOn(all_changes));
  EXPECT_FALSE(can_trigger_gc.MayDependOn(all_changes));

  EXPECT_TRUE(all_changes.Includes(can_trigger_gc));
  EXPECT_FALSE(all_changes.Includes(depends_on_gc));
  EXPECT_TRUE(all_dependencies.Includes(depends_on_gc));
  EXPECT_FALSE(all_dependencies.Includes(can_trigger_gc));
}

TEST(SideEffectsTest, BitStrings) {
  EXPECT_STREQ(
      "|||||||",
      SideEffects::None().ToString().c_str());
  EXPECT_STREQ(
      "|GC|DFJISCBZL|DFJISCBZL|GC|DFJISCBZL|DFJISCBZL|",
      SideEffects::All().ToString().c_str());
  EXPECT_STREQ(
      "|||||DFJISCBZL|DFJISCBZL|",
      SideEffects::AllWrites().ToString().c_str());
  EXPECT_STREQ(
      "||DFJISCBZL|DFJISCBZL||||",
      SideEffects::AllReads().ToString().c_str());
  EXPECT_STREQ(
      "||||||L|",
      SideEffects::FieldWriteOfType(DataType::Type::kReference, false).ToString().c_str());
  EXPECT_STREQ(
      "||DFJISCBZL|DFJISCBZL||DFJISCBZL|DFJISCBZL|",
      SideEffects::FieldWriteOfType(DataType::Type::kReference, true).ToString().c_str());
  EXPECT_STREQ(
      "|||||Z||",
      SideEffects::ArrayWriteOfType(DataType::Type::kBool).ToString().c_str());
  EXPECT_STREQ(
      "|||||C||",
      SideEffects::ArrayWriteOfType(DataType::Type::kUint16).ToString().c_str());
  EXPECT_STREQ(
      "|||||S||",
      SideEffects::ArrayWriteOfType(DataType::Type::kInt16).ToString().c_str());
  EXPECT_STREQ(
      "|||B||||",
      SideEffects::FieldReadOfType(DataType::Type::kInt8, false).ToString().c_str());
  EXPECT_STREQ(
      "||D|||||",
      SideEffects::ArrayReadOfType(DataType::Type::kFloat64).ToString().c_str());
  EXPECT_STREQ(
      "||J|||||",
      SideEffects::ArrayReadOfType(DataType::Type::kInt64).ToString().c_str());
  EXPECT_STREQ(
      "||F|||||",
      SideEffects::ArrayReadOfType(DataType::Type::kFloat32).ToString().c_str());
  EXPECT_STREQ(
      "||I|||||",
      SideEffects::ArrayReadOfType(DataType::Type::kInt32).ToString().c_str());
  SideEffects s = SideEffects::None();
  s = s.Union(SideEffects::FieldWriteOfType(DataType::Type::kUint16, /* is_volatile */ false));
  s = s.Union(SideEffects::FieldWriteOfType(DataType::Type::kInt64, /* is_volatile */ false));
  s = s.Union(SideEffects::ArrayWriteOfType(DataType::Type::kInt16));
  s = s.Union(SideEffects::FieldReadOfType(DataType::Type::kInt32, /* is_volatile */ false));
  s = s.Union(SideEffects::ArrayReadOfType(DataType::Type::kFloat32));
  s = s.Union(SideEffects::ArrayReadOfType(DataType::Type::kFloat64));
  EXPECT_STREQ("||DF|I||S|JC|", s.ToString().c_str());
}

}  // namespace art