class Z4 {
public:
Z4() : value_(0) {}
explicit Z4(int x) : value_(x > 0 ? (x & 3) : ((-x) & 3)) {}
bool operator==(
const Z4& rhs)
const {
return value_ == rhs.value_; }
bool operator!=(
const Z4& rhs)
const {
return value_ != rhs.value_; }
Z4& operator+=(const Z4& rhs) {
value_ = (value_ + rhs.value_) & 3;
return *this;
}
int value() const { return value_; }
Z4& operator++() {
value_ = (value_ + 1) & 3;
return *this;
}
private:
int value_;
};
str << "Z4(" << data.value() << ")";
return str;
}
Z4 result(lhs);
result += rhs;
return result;
}
class Q4 {
public:
enum ValueType {
kOne = 0,
kI = 1,
kJ = 2,
kK = 3,
kMinusOne = 4,
kMinusI = 5,
kMinusJ = 6,
kMinusK = 7
};
Q4() : value_(kOne) {}
explicit Q4(int x) : value_(static_cast<ValueType>(x > 0 ? x % 8 : -x % 8)) {}
bool operator==(
const Q4& rhs)
const {
return value_ == rhs.value_; }
bool operator!=(
const Q4& rhs)
const {
return value_ != rhs.value_; }
Q4& operator+=(const Q4& rhs);
ValueType value() const { return value_; }
Q4& operator++() {
value_ = static_cast<ValueType>((value_ + 1) % 8);
return *this;
}
private:
ValueType value_;
};
Q4& Q4::operator+=(const Q4& rhs) {
static const ValueType table[8][8] = {{kOne, kI, kJ, kK, kMinusOne, kMinusI, kMinusJ, kMinusK},
{kI, kMinusOne, kK, kMinusJ, kMinusI, kOne, kMinusK, kJ},
{kJ, kMinusK, kMinusOne, kI, kMinusJ, kK, kOne, kMinusI},
{kK, kJ, kMinusI, kMinusOne, kMinusK, kMinusJ, kI, kOne},
{kMinusOne, kMinusI, kMinusJ, kMinusK, kOne, kI, kJ, kK},
{kMinusI, kOne, kMinusK, kJ, kI, kMinusOne, kK, kMinusJ},
{kMinusJ, kK, kOne, kMinusI, kJ, kMinusK, kMinusOne, kI},
{kMinusK, kMinusJ, kI, kOne, kK, kJ, kMinusI, kMinusOne}};
value_ = table[value_][rhs.value_];
return *this;
}
switch (data.value()) {
case Q4::kOne:
str << "1";
break;
case Q4::kI:
str << "i";
break;
case Q4::kJ:
str << "j";
break;
case Q4::kK:
str << "k";
break;
case Q4::kMinusOne:
str << "-1";
break;
case Q4::kMinusI:
str << "-i";
break;
case Q4::kMinusJ:
str << "-j";
break;
case Q4::kMinusK:
str << "-k";
break;
default:
str << "ERROR";
break;
}
return str;
}
Q4 result(lhs);
result += rhs;
return result;
}
template <class T>
class GroupTest : public ::testing::Test {
public:
};
typedef ::testing::Types<Z4, Q4, unsigned char> MyTypes;
TypeParam x = TypeParam();
TypeParam y = TypeParam(x);
x = y;
TypeParam z = x;
++z;
}
TypeParam e = TypeParam();
TypeParam a = TypeParam();
TypeParam b = TypeParam();
TypeParam c = TypeParam();
do {
do {
do {
ASSERT_EQ(a + (b + c), (a + b) + c) <<
"a = " << a <<
", " << "b = " << b << ", "
<< "c = " << c;
++c;
} while (e != c);
++b;
} while (e != b);
++a;
} while (e != a);
}
TypeParam e = TypeParam();
TypeParam a = TypeParam();
do {
++a;
} while (e != a);
}
TypeParam e = TypeParam();
TypeParam a = TypeParam();
do {
bool success = false;
TypeParam b = TypeParam();
do {
if (e == a + b) {
success = true;
break;
}
} while (e != b);
} while (e != a);
}
NLIB_PATHMAPPER_FORSAMPLE
bool SampleMain(int argc, char** argv) {
InitPathMapperForSample();
char path[512];
char buf[512];
size_t count;
g_pathmapper.ResolvePath(&count, path, "nlibpath:///readwrite/param_type.xml");
::testing::GTEST_FLAG(output) = buf;
}
NLIB_MAINFUNC