mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2024-12-08 07:41:04 +01:00
616fdbf3ff
- 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.
446 lines
10 KiB
C++
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();
|
|
}
|