cef/libcef/common/test/translator_test_impl.cc

// Copyright (c) 2015 The Chromium Embedded Framework 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 "cef/include/test/cef_translator_test.h"

namespace {

class CefTranslatorTestRefPtrLibraryImpl
    : public CefTranslatorTestRefPtrLibrary {
 public:
  explicit CefTranslatorTestRefPtrLibraryImpl(int value) : value_(value) {}

  CefTranslatorTestRefPtrLibraryImpl(
      const CefTranslatorTestRefPtrLibraryImpl&) = delete;
  CefTranslatorTestRefPtrLibraryImpl& operator=(
      const CefTranslatorTestRefPtrLibraryImpl&) = delete;

  int GetValue() override { return value_; }

  void SetValue(int value) override { value_ = value; }

 private:
  int value_;

  IMPLEMENT_REFCOUNTING(CefTranslatorTestRefPtrLibraryImpl);
};

}  // namespace

// static
CefRefPtr<CefTranslatorTestRefPtrLibrary>
CefTranslatorTestRefPtrLibrary::Create(int value) {
  return new CefTranslatorTestRefPtrLibraryImpl(value);
}

namespace {

class CefTranslatorTestRefPtrLibraryChildImpl
    : public CefTranslatorTestRefPtrLibraryChild {
 public:
  CefTranslatorTestRefPtrLibraryChildImpl(int value, int other_value)
      : value_(value), other_value_(other_value) {}

  CefTranslatorTestRefPtrLibraryChildImpl(
      const CefTranslatorTestRefPtrLibraryChildImpl&) = delete;
  CefTranslatorTestRefPtrLibraryChildImpl& operator=(
      const CefTranslatorTestRefPtrLibraryChildImpl&) = delete;

  int GetValue() override { return value_; }

  void SetValue(int value) override { value_ = value; }

  int GetOtherValue() override { return other_value_; }

  void SetOtherValue(int value) override { other_value_ = value; }

 private:
  int value_;
  int other_value_;

  IMPLEMENT_REFCOUNTING(CefTranslatorTestRefPtrLibraryChildImpl);
};

}  // namespace

// static
CefRefPtr<CefTranslatorTestRefPtrLibraryChild>
CefTranslatorTestRefPtrLibraryChild::Create(int value, int other_value) {
  return new CefTranslatorTestRefPtrLibraryChildImpl(value, other_value);
}

namespace {

class CefTranslatorTestRefPtrLibraryChildChildImpl
    : public CefTranslatorTestRefPtrLibraryChildChild {
 public:
  CefTranslatorTestRefPtrLibraryChildChildImpl(int value,
                                               int other_value,
                                               int other_other_value)
      : value_(value),
        other_value_(other_value),
        other_other_value_(other_other_value) {}

  CefTranslatorTestRefPtrLibraryChildChildImpl(
      const CefTranslatorTestRefPtrLibraryChildChildImpl&) = delete;
  CefTranslatorTestRefPtrLibraryChildChildImpl& operator=(
      const CefTranslatorTestRefPtrLibraryChildChildImpl&) = delete;

  int GetValue() override { return value_; }

  void SetValue(int value) override { value_ = value; }

  int GetOtherValue() override { return other_value_; }

  void SetOtherValue(int value) override { other_value_ = value; }

  int GetOtherOtherValue() override { return other_other_value_; }

  void SetOtherOtherValue(int value) override { other_other_value_ = value; }

 private:
  int value_;
  int other_value_;
  int other_other_value_;

  IMPLEMENT_REFCOUNTING(CefTranslatorTestRefPtrLibraryChildChildImpl);
};

}  // namespace

// static
CefRefPtr<CefTranslatorTestRefPtrLibraryChildChild>
CefTranslatorTestRefPtrLibraryChildChild::Create(int value,
                                                 int other_value,
                                                 int other_other_value) {
  return new CefTranslatorTestRefPtrLibraryChildChildImpl(value, other_value,
                                                          other_other_value);
}

namespace {

class CefTranslatorTestScopedLibraryImpl
    : public CefTranslatorTestScopedLibrary {
 public:
  explicit CefTranslatorTestScopedLibraryImpl(int value) : value_(value) {}

  CefTranslatorTestScopedLibraryImpl(
      const CefTranslatorTestScopedLibraryImpl&) = delete;
  CefTranslatorTestScopedLibraryImpl& operator=(
      const CefTranslatorTestScopedLibraryImpl&) = delete;

  int GetValue() override { return value_; }

  void SetValue(int value) override { value_ = value; }

 private:
  int value_;
};

}  // namespace

// static
CefOwnPtr<CefTranslatorTestScopedLibrary>
CefTranslatorTestScopedLibrary::Create(int value) {
  return CefOwnPtr<CefTranslatorTestScopedLibrary>(
      new CefTranslatorTestScopedLibraryImpl(value));
}

namespace {

class CefTranslatorTestScopedLibraryChildImpl
    : public CefTranslatorTestScopedLibraryChild {
 public:
  CefTranslatorTestScopedLibraryChildImpl(int value, int other_value)
      : value_(value), other_value_(other_value) {}

  CefTranslatorTestScopedLibraryChildImpl(
      const CefTranslatorTestScopedLibraryChildImpl&) = delete;
  CefTranslatorTestScopedLibraryChildImpl& operator=(
      const CefTranslatorTestScopedLibraryChildImpl&) = delete;

  int GetValue() override { return value_; }

  void SetValue(int value) override { value_ = value; }

  int GetOtherValue() override { return other_value_; }

  void SetOtherValue(int value) override { other_value_ = value; }

 private:
  int value_;
  int other_value_;
};

}  // namespace

// static
CefOwnPtr<CefTranslatorTestScopedLibraryChild>
CefTranslatorTestScopedLibraryChild::Create(int value, int other_value) {
  return CefOwnPtr<CefTranslatorTestScopedLibraryChild>(
      new CefTranslatorTestScopedLibraryChildImpl(value, other_value));
}

namespace {

class CefTranslatorTestScopedLibraryChildChildImpl
    : public CefTranslatorTestScopedLibraryChildChild {
 public:
  CefTranslatorTestScopedLibraryChildChildImpl(int value,
                                               int other_value,
                                               int other_other_value)
      : value_(value),
        other_value_(other_value),
        other_other_value_(other_other_value) {}

  CefTranslatorTestScopedLibraryChildChildImpl(
      const CefTranslatorTestScopedLibraryChildChildImpl&) = delete;
  CefTranslatorTestScopedLibraryChildChildImpl& operator=(
      const CefTranslatorTestScopedLibraryChildChildImpl&) = delete;

  int GetValue() override { return value_; }

  void SetValue(int value) override { value_ = value; }

  int GetOtherValue() override { return other_value_; }

  void SetOtherValue(int value) override { other_value_ = value; }

  int GetOtherOtherValue() override { return other_other_value_; }

  void SetOtherOtherValue(int value) override { other_other_value_ = value; }

 private:
  int value_;
  int other_value_;
  int other_other_value_;
};

}  // namespace

// static
CefOwnPtr<CefTranslatorTestScopedLibraryChildChild>
CefTranslatorTestScopedLibraryChildChild::Create(int value,
                                                 int other_value,
                                                 int other_other_value) {
  return CefOwnPtr<CefTranslatorTestScopedLibraryChildChild>(
      new CefTranslatorTestScopedLibraryChildChildImpl(value, other_value,
                                                       other_other_value));
}

namespace {

class CefTranslatorTestImpl : public CefTranslatorTest {
 public:
  CefTranslatorTestImpl() = default;

  CefTranslatorTestImpl(const CefTranslatorTestImpl&) = delete;
  CefTranslatorTestImpl& operator=(const CefTranslatorTestImpl&) = delete;

  // PRIMITIVE VALUES

  void GetVoid() override {}

  bool GetBool() override { return TEST_BOOL_VAL; }

  int GetInt() override { return TEST_INT_VAL; }

  double GetDouble() override { return TEST_DOUBLE_VAL; }

  long GetLong() override { return TEST_LONG_VAL; }

  size_t GetSizet() override { return TEST_SIZET_VAL; }

  bool SetVoid() override { return true; }

  bool SetBool(bool val) override { return (val == TEST_BOOL_VAL); }

  bool SetInt(int val) override { return (val == TEST_INT_VAL); }

  bool SetDouble(double val) override { return (val == TEST_DOUBLE_VAL); }

  bool SetLong(long val) override { return (val == TEST_LONG_VAL); }

  bool SetSizet(size_t val) override { return (val == TEST_SIZET_VAL); }

  // PRIMITIVE LIST VALUES

  bool SetIntList(const std::vector<int>& val) override {
    if (val.size() != 2U) {
      return false;
    }
    return val[0] == TEST_INT_VAL && val[1] == TEST_INT_VAL2;
  }

  bool GetIntListByRef(IntList& val) override {
    if (val.size() != GetIntListSize()) {
      return false;
    }
    val.clear();
    val.push_back(TEST_INT_VAL);
    val.push_back(TEST_INT_VAL2);
    return true;
  }

  size_t GetIntListSize() override { return 2U; }

  // STRING VALUES

  CefString GetString() override { return TEST_STRING_VAL; }

  bool SetString(const CefString& val) override {
    return (val.ToString() == TEST_STRING_VAL);
  }

  void GetStringByRef(CefString& val) override { val = TEST_STRING_VAL; }

  // STRING LIST VALUES

  bool SetStringList(const std::vector<CefString>& val) override {
    if (val.size() != 3U) {
      return false;
    }
    return val[0] == TEST_STRING_VAL && val[1] == TEST_STRING_VAL2 &&
           val[2] == TEST_STRING_VAL3;
  }

  bool GetStringListByRef(StringList& val) override {
    if (val.size() != 0U) {
      return false;
    }
    val.push_back(TEST_STRING_VAL);
    val.push_back(TEST_STRING_VAL2);
    val.push_back(TEST_STRING_VAL3);
    return true;
  }

  // STRING MAP VALUES

  bool SetStringMap(const StringMap& val) override {
    if (val.size() != 3U) {
      return false;
    }

    StringMap::const_iterator it;

    it = val.find(TEST_STRING_KEY);
    if (it == val.end() || it->second != TEST_STRING_VAL) {
      return false;
    }
    it = val.find(TEST_STRING_KEY2);
    if (it == val.end() || it->second != TEST_STRING_VAL2) {
      return false;
    }
    it = val.find(TEST_STRING_KEY3);
    if (it == val.end() || it->second != TEST_STRING_VAL3) {
      return false;
    }
    return true;
  }

  bool GetStringMapByRef(std::map<CefString, CefString>& val) override {
    if (val.size() != 0U) {
      return false;
    }

    val.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
    val.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
    val.insert(std::make_pair(TEST_STRING_KEY3, TEST_STRING_VAL3));
    return true;
  }

  // STRING MULTIMAP VALUES

  bool SetStringMultimap(
      const std::multimap<CefString, CefString>& val) override {
    if (val.size() != 3U) {
      return false;
    }

    StringMultimap::const_iterator it;

    it = val.find(TEST_STRING_KEY);
    if (it == val.end() || it->second != TEST_STRING_VAL) {
      return false;
    }
    it = val.find(TEST_STRING_KEY2);
    if (it == val.end() || it->second != TEST_STRING_VAL2) {
      return false;
    }
    it = val.find(TEST_STRING_KEY3);
    if (it == val.end() || it->second != TEST_STRING_VAL3) {
      return false;
    }
    return true;
  }

  bool GetStringMultimapByRef(StringMultimap& val) override {
    if (val.size() != 0U) {
      return false;
    }

    val.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
    val.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
    val.insert(std::make_pair(TEST_STRING_KEY3, TEST_STRING_VAL3));
    return true;
  }

  // STRUCT VALUES

  CefPoint GetPoint() override { return CefPoint(TEST_X_VAL, TEST_Y_VAL); }

  bool SetPoint(const CefPoint& val) override {
    return val.x == TEST_X_VAL && val.y == TEST_Y_VAL;
  }

  void GetPointByRef(CefPoint& val) override {
    val = CefPoint(TEST_X_VAL, TEST_Y_VAL);
  }

  // STRUCT LIST VALUES

  bool SetPointList(const std::vector<CefPoint>& val) override {
    if (val.size() != 2U) {
      return false;
    }
    return val[0].x == TEST_X_VAL && val[0].y == TEST_Y_VAL &&
           val[1].x == TEST_X_VAL2 && val[1].y == TEST_Y_VAL2;
  }

  bool GetPointListByRef(PointList& val) override {
    if (val.size() != GetPointListSize()) {
      return false;
    }
    val.clear();
    val.emplace_back(TEST_X_VAL, TEST_Y_VAL);
    val.emplace_back(TEST_X_VAL2, TEST_Y_VAL2);
    return true;
  }

  size_t GetPointListSize() override { return 2U; }

  // LIBRARY-SIDE REFPTR VALUES

  CefRefPtr<CefTranslatorTestRefPtrLibrary> GetRefPtrLibrary(int val) override {
    return new CefTranslatorTestRefPtrLibraryChildImpl(val, 0);
  }

  int SetRefPtrLibrary(CefRefPtr<CefTranslatorTestRefPtrLibrary> val) override {
    return val->GetValue();
  }

  CefRefPtr<CefTranslatorTestRefPtrLibrary> SetRefPtrLibraryAndReturn(
      CefRefPtr<CefTranslatorTestRefPtrLibrary> val) override {
    return val;
  }

  int SetChildRefPtrLibrary(
      CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val) override {
    return val->GetValue();
  }

  CefRefPtr<CefTranslatorTestRefPtrLibrary>
  SetChildRefPtrLibraryAndReturnParent(
      CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val) override {
    return val;
  }

  // LIBRARY-SIDE REFPTR LIST VALUES

  bool SetRefPtrLibraryList(
      const std::vector<CefRefPtr<CefTranslatorTestRefPtrLibrary>>& val,
      int val1,
      int val2) override {
    if (val.size() != 2U) {
      return false;
    }
    return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
  }

  bool GetRefPtrLibraryListByRef(RefPtrLibraryList& val,
                                 int val1,
                                 int val2) override {
    if (val.size() != GetRefPtrLibraryListSize()) {
      return false;
    }
    val.clear();
    val.push_back(new CefTranslatorTestRefPtrLibraryChildImpl(val1, 0));
    val.push_back(new CefTranslatorTestRefPtrLibraryImpl(val2));
    return true;
  }

  size_t GetRefPtrLibraryListSize() override { return 2U; }

  // CLIENT-SIDE REFPTR VALUES

  int SetRefPtrClient(CefRefPtr<CefTranslatorTestRefPtrClient> val) override {
    return val->GetValue();
  }

  CefRefPtr<CefTranslatorTestRefPtrClient> SetRefPtrClientAndReturn(
      CefRefPtr<CefTranslatorTestRefPtrClient> val) override {
    return val;
  }

  int SetChildRefPtrClient(
      CefRefPtr<CefTranslatorTestRefPtrClientChild> val) override {
    return val->GetValue();
  }

  CefRefPtr<CefTranslatorTestRefPtrClient> SetChildRefPtrClientAndReturnParent(
      CefRefPtr<CefTranslatorTestRefPtrClientChild> val) override {
    return val;
  }

  // CLIENT-SIDE REFPTR LIST VALUES

  bool SetRefPtrClientList(
      const std::vector<CefRefPtr<CefTranslatorTestRefPtrClient>>& val,
      int val1,
      int val2) override {
    if (val.size() != 2U) {
      return false;
    }
    return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
  }

  bool GetRefPtrClientListByRef(
      RefPtrClientList& val,
      CefRefPtr<CefTranslatorTestRefPtrClient> val1,
      CefRefPtr<CefTranslatorTestRefPtrClient> val2) override {
    if (val.size() != GetRefPtrClientListSize()) {
      return false;
    }
    val.clear();
    val.push_back(val1);
    val.push_back(val2);
    return true;
  }

  size_t GetRefPtrClientListSize() override { return 2U; }

  // LIBRARY-SIDE OWNPTR VALUES

  CefOwnPtr<CefTranslatorTestScopedLibrary> GetOwnPtrLibrary(int val) override {
    return CefOwnPtr<CefTranslatorTestScopedLibrary>(
        new CefTranslatorTestScopedLibraryChildImpl(val, 0));
  }

  int SetOwnPtrLibrary(CefOwnPtr<CefTranslatorTestScopedLibrary> val) override {
    return val->GetValue();
  }

  CefOwnPtr<CefTranslatorTestScopedLibrary> SetOwnPtrLibraryAndReturn(
      CefOwnPtr<CefTranslatorTestScopedLibrary> val) override {
    return val;
  }

  int SetChildOwnPtrLibrary(
      CefOwnPtr<CefTranslatorTestScopedLibraryChild> val) override {
    return val->GetValue();
  }

  CefOwnPtr<CefTranslatorTestScopedLibrary>
  SetChildOwnPtrLibraryAndReturnParent(
      CefOwnPtr<CefTranslatorTestScopedLibraryChild> val) override {
    return CefOwnPtr<CefTranslatorTestScopedLibrary>(val.release());
  }

  // CLIENT-SIDE OWNPTR VALUES

  int SetOwnPtrClient(CefOwnPtr<CefTranslatorTestScopedClient> val) override {
    return val->GetValue();
  }

  CefOwnPtr<CefTranslatorTestScopedClient> SetOwnPtrClientAndReturn(
      CefOwnPtr<CefTranslatorTestScopedClient> val) override {
    return val;
  }

  int SetChildOwnPtrClient(
      CefOwnPtr<CefTranslatorTestScopedClientChild> val) override {
    return val->GetValue();
  }

  CefOwnPtr<CefTranslatorTestScopedClient> SetChildOwnPtrClientAndReturnParent(
      CefOwnPtr<CefTranslatorTestScopedClientChild> val) override {
    return CefOwnPtr<CefTranslatorTestScopedClient>(val.release());
  }

  // LIBRARY-SIDE RAWPTR VALUES

  int SetRawPtrLibrary(CefRawPtr<CefTranslatorTestScopedLibrary> val) override {
    return val->GetValue();
  }

  int SetChildRawPtrLibrary(
      CefRawPtr<CefTranslatorTestScopedLibraryChild> val) override {
    return val->GetValue();
  }

  // LIBRARY-SIDE RAWPTR LIST VALUES

  bool SetRawPtrLibraryList(
      const std::vector<CefRawPtr<CefTranslatorTestScopedLibrary>>& val,
      int val1,
      int val2) override {
    if (val.size() != 2U) {
      return false;
    }
    return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
  }

  // CLIENT-SIDE RAWPTR VALUES

  int SetRawPtrClient(CefRawPtr<CefTranslatorTestScopedClient> val) override {
    return val->GetValue();
  }

  int SetChildRawPtrClient(
      CefRawPtr<CefTranslatorTestScopedClientChild> val) override {
    return val->GetValue();
  }

  // CLIENT-SIDE RAWPTR LIST VALUES

  bool SetRawPtrClientList(
      const std::vector<CefRawPtr<CefTranslatorTestScopedClient>>& val,
      int val1,
      int val2) override {
    if (val.size() != 2U) {
      return false;
    }
    return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
  }

 private:
  IMPLEMENT_REFCOUNTING(CefTranslatorTestImpl);
};

}  // namespace

// static
CefRefPtr<CefTranslatorTest> CefTranslatorTest::Create() {
  return new CefTranslatorTestImpl();
}