cef/libcef/common/test/translator_test_impl.cc
Marshall Greenblatt 616fdbf3ff Improve inheritance support in the CEF API (issue #1623).
- Support single parent inheritance in CEF API classes.
- Support non-virtual inheritance in CEF API classes.
- Support translation of CEF API sub-directories.
- Add test sub-directories for testing-only functionality that will be
  available to unit tests but not exposed via the binary distribution.
- Add unit tests for the translator tool.
- Fix parsing of template parameter types that include commas.
2015-05-05 17:16:44 -04:00

446 lines
10 KiB
C++

// 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 "include/test/cef_translator_test.h"
class CefTranslatorTestObjectImpl : public CefTranslatorTestObject {
public:
explicit CefTranslatorTestObjectImpl(int value)
: value_(value) {
}
int GetValue() override {
return value_;
}
void SetValue(int value) override {
value_ = value;
}
protected:
int value_;
private:
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestObjectImpl);
IMPLEMENT_REFCOUNTING(CefTranslatorTestObjectImpl);
};
// static
CefRefPtr<CefTranslatorTestObject> CefTranslatorTestObject::Create(int value) {
return new CefTranslatorTestObjectImpl(value);
}
class CefTranslatorTestObjectChildImpl : public CefTranslatorTestObjectChild {
public:
CefTranslatorTestObjectChildImpl(int value, int other_value)
: value_(value),
other_value_(other_value) {
}
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;
}
protected:
int value_;
int other_value_;
private:
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestObjectChildImpl);
IMPLEMENT_REFCOUNTING(CefTranslatorTestObjectChildImpl);
};
// static
CefRefPtr<CefTranslatorTestObjectChild> CefTranslatorTestObjectChild::Create(
int value,
int other_value) {
return new CefTranslatorTestObjectChildImpl(value, other_value);
}
class CefTranslatorTestObjectChildChildImpl :
public CefTranslatorTestObjectChildChild {
public:
CefTranslatorTestObjectChildChildImpl(int value,
int other_value,
int other_other_value)
: value_(value),
other_value_(other_value),
other_other_value_(other_other_value) {
}
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;
}
protected:
int value_;
int other_value_;
int other_other_value_;
private:
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestObjectChildChildImpl);
IMPLEMENT_REFCOUNTING(CefTranslatorTestObjectChildChildImpl);
};
// static
CefRefPtr<CefTranslatorTestObjectChildChild>
CefTranslatorTestObjectChildChild::Create(
int value,
int other_value,
int other_other_value) {
return new CefTranslatorTestObjectChildChildImpl(value, other_value,
other_other_value);
}
class CefTranslatorTestImpl : public CefTranslatorTest {
public:
CefTranslatorTestImpl() {
}
// 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.push_back(CefPoint(TEST_X_VAL, TEST_Y_VAL));
val.push_back(CefPoint(TEST_X_VAL2, TEST_Y_VAL2));
return true;
}
size_t GetPointListSize() override {
return 2U;
}
// LIBRARY-SIDE OBJECT VALUES
CefRefPtr<CefTranslatorTestObject> GetObject(int val) override {
return new CefTranslatorTestObjectChildImpl(val, 0);
}
int SetObject(CefRefPtr<CefTranslatorTestObject> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestObject> SetObjectAndReturn(
CefRefPtr<CefTranslatorTestObject> val) override {
return val;
}
int SetChildObject(CefRefPtr<CefTranslatorTestObjectChild> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestObject> SetChildObjectAndReturnParent(
CefRefPtr<CefTranslatorTestObjectChild> val) override {
return val;
}
// LIBRARY-SIDE OBJECT LIST VALUES
bool SetObjectList(
const std::vector<CefRefPtr<CefTranslatorTestObject> >& val,
int val1, int val2) override {
if (val.size() != 2U)
return false;
return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
}
bool GetObjectListByRef(ObjectList& val, int val1, int val2) override {
if (val.size() != GetObjectListSize())
return false;
val.clear();
val.push_back(new CefTranslatorTestObjectChildImpl(val1, 0));
val.push_back(new CefTranslatorTestObjectImpl(val2));
return true;
}
size_t GetObjectListSize() override {
return 2U;
}
// CLIENT-SIDE OBJECT VALUES
int SetHandler(CefRefPtr<CefTranslatorTestHandler> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestHandler> SetHandlerAndReturn(
CefRefPtr<CefTranslatorTestHandler> val) override {
return val;
}
int SetChildHandler(CefRefPtr<CefTranslatorTestHandlerChild> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestHandler> SetChildHandlerAndReturnParent(
CefRefPtr<CefTranslatorTestHandlerChild> val) override {
return val;
}
// CLIENT-SIDE OBJECT LIST VALUES
bool SetHandlerList(
const std::vector<CefRefPtr<CefTranslatorTestHandler> >& val,
int val1, int val2) override {
if (val.size() != 2U)
return false;
return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
}
bool GetHandlerListByRef(
HandlerList& val,
CefRefPtr<CefTranslatorTestHandler> val1,
CefRefPtr<CefTranslatorTestHandler> val2) override {
if (val.size() != GetHandlerListSize())
return false;
val.clear();
val.push_back(val1);
val.push_back(val2);
return true;
}
size_t GetHandlerListSize() override {
return 2U;
}
private:
IMPLEMENT_REFCOUNTING(CefTranslatorTestImpl);
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestImpl);
};
// static
CefRefPtr<CefTranslatorTest> CefTranslatorTest::Create() {
return new CefTranslatorTestImpl();
}