[apple/icu.git] / icuSources / test / intltest / pluralmaptest.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2014-2015, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
* File PLURALMAPTEST.CPP
*
********************************************************************************
*/
#include "unicode/unistr.h"

#include "intltest.h"
#include "pluralmap.h"

class PluralMapForPluralMapTest : public PluralMap<UnicodeString> {
public:
    UBool operator==(const PluralMapForPluralMapTest &other) {
        return equals(other, strEqual);
    }
private:
    static UBool strEqual(const UnicodeString &lhs, const UnicodeString &rhs) {
        return lhs == rhs;
    }
};

class PluralMapTest : public IntlTest {
public:
    PluralMapTest() {
    }
    void TestToCategory();
    void TestGetCategoryName();
    void TestGet();
    void TestIterate();
    void TestEqual();
    void TestCopyAndAssign();
    void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
    void addVariant(
            PluralMapBase::Category v,
            const UnicodeString &value,
            PluralMapForPluralMapTest &map);
private:
};

void PluralMapTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
  TESTCASE_AUTO_BEGIN;
  TESTCASE_AUTO(TestToCategory);
  TESTCASE_AUTO(TestGetCategoryName);
  TESTCASE_AUTO(TestGet);
  TESTCASE_AUTO(TestIterate);
  TESTCASE_AUTO(TestEqual);
  TESTCASE_AUTO(TestCopyAndAssign);
  TESTCASE_AUTO_END;
}

void PluralMapTest::TestToCategory() {
    assertEquals("", (int32_t)PluralMapBase::OTHER, PluralMapBase::toCategory("other"));
    assertEquals("", (int32_t)PluralMapBase::ZERO, PluralMapBase::toCategory("zero"));
    assertEquals("", (int32_t)PluralMapBase::ONE, PluralMapBase::toCategory("one"));
    assertEquals("", (int32_t)PluralMapBase::TWO, PluralMapBase::toCategory("two"));
    assertEquals("", (int32_t)PluralMapBase::FEW, PluralMapBase::toCategory("few"));
    assertEquals("", (int32_t)PluralMapBase::MANY, PluralMapBase::toCategory("many"));
    assertEquals("", (int32_t)PluralMapBase::NONE, PluralMapBase::toCategory("Many"));
    assertEquals(
            "",
            (int32_t)PluralMapBase::FEW,
            PluralMapBase::toCategory(UnicodeString("few")));
    assertEquals(
            "",
            (int32_t)PluralMapBase::MANY,
            PluralMapBase::toCategory(UnicodeString("many")));
    assertEquals(
            "",
            (int32_t)PluralMapBase::NONE,
            PluralMapBase::toCategory(UnicodeString("Many")));
}

void PluralMapTest::TestGetCategoryName() {
    assertTrue("", PluralMapBase::getCategoryName(PluralMapBase::NONE) == NULL);
    assertTrue("", PluralMapBase::getCategoryName(PluralMapBase::CATEGORY_COUNT) == NULL);
    assertEquals("", "other", PluralMapBase::getCategoryName(PluralMapBase::OTHER));
    assertEquals("", "zero", PluralMapBase::getCategoryName(PluralMapBase::ZERO));
    assertEquals("", "one", PluralMapBase::getCategoryName(PluralMapBase::ONE));
    assertEquals("", "two", PluralMapBase::getCategoryName(PluralMapBase::TWO));
    assertEquals("", "few", PluralMapBase::getCategoryName(PluralMapBase::FEW));
    assertEquals("", "many", PluralMapBase::getCategoryName(PluralMapBase::MANY));
}

void PluralMapTest::TestGet() {
    PluralMapForPluralMapTest map;
    addVariant(PluralMapBase::OTHER, "pickles", map);
    addVariant(PluralMapBase::ONE, "pickle", map);
    addVariant(PluralMapBase::FEW, "picklefew", map);
    assertEquals("", "pickles", map.get(PluralMapBase::OTHER));
    assertEquals("", "pickle", map.get(PluralMapBase::ONE));
    assertEquals("", "picklefew", map.get(PluralMapBase::FEW));
    assertEquals("", "pickles", map.get(PluralMapBase::MANY));
    assertEquals("", "pickles", map.get(PluralMapBase::NONE));
    assertEquals("", "pickles", map.get(PluralMapBase::CATEGORY_COUNT));
    assertEquals("", "picklefew", map.get("few"));
    assertEquals("", "pickles", map.get("many"));
    assertEquals("", "pickles", map.get("somebadform"));
    assertEquals("", "pickle", map.get(UnicodeString("one")));
    assertEquals("", "pickles", map.get(UnicodeString("many")));
    assertEquals("", "pickles", map.get(UnicodeString("somebadform")));
    assertEquals("", "pickles", map.getOther());
}

void PluralMapTest::TestIterate() {
    PluralMapForPluralMapTest map;
    addVariant(PluralMapBase::OTHER, "pickles", map);
    addVariant(PluralMapBase::ONE, "pickle", map);
    addVariant(PluralMapBase::FEW, "pickleops", map);
    addVariant(PluralMapBase::FEW, "picklefew", map);
    PluralMapBase::Category index = PluralMapBase::NONE;
    const UnicodeString *current = map.next(index);
    assertEquals("", "pickles", *current);
    assertEquals("", (int32_t)PluralMapBase::OTHER, index);
    current = map.next(index);
    assertEquals("", "pickle", *current);
    assertEquals("", (int32_t)PluralMapBase::ONE, index);
    current = map.next(index);
    assertEquals("", "picklefew", *current);
    assertEquals("", (int32_t)PluralMapBase::FEW, index);
    current = map.next(index);
    assertEquals("", (int32_t)PluralMapBase::CATEGORY_COUNT, index);
    assertTrue("", current == NULL);

    PluralMapForPluralMapTest map2;
    index = PluralMapBase::NONE;
    current = map2.next(index);
    assertEquals("", "", *current);
    assertEquals("", (int32_t)PluralMapBase::OTHER, index);
    current = map2.next(index);
    assertEquals("", (int32_t)PluralMapBase::CATEGORY_COUNT, index);
    assertTrue("", current == NULL);
}

void PluralMapTest::TestEqual() {
    PluralMapForPluralMapTest control;
    addVariant(PluralMapBase::OTHER, "pickles", control);
    addVariant(PluralMapBase::ONE, "pickle", control);
    addVariant(PluralMapBase::FEW, "picklefew", control);

    {
        PluralMapForPluralMapTest map;
        addVariant(PluralMapBase::FEW, "picklefew", map);
        addVariant(PluralMapBase::OTHER, "pickles", map);
        addVariant(PluralMapBase::ONE, "pickle", map);
        assertTrue("", control == map);
        addVariant(PluralMapBase::ONE, "pickl", map);
        assertFalse("", control == map);
    }
    {
        PluralMapForPluralMapTest map;
        addVariant(PluralMapBase::MANY, "picklemany", map);
        addVariant(PluralMapBase::OTHER, "pickles", map);
        addVariant(PluralMapBase::ONE, "pickle", map);
        assertFalse("", control == map);
    }
}

void PluralMapTest::TestCopyAndAssign() {
    PluralMapForPluralMapTest control;
    addVariant(PluralMapBase::OTHER, "pickles", control);
    addVariant(PluralMapBase::ONE, "pickle", control);
    addVariant(PluralMapBase::FEW, "picklefew", control);
    {
        PluralMapForPluralMapTest *rhs = new PluralMapForPluralMapTest();
        if (rhs == NULL) {
            errln("Memory allocation error.");
            return;
        }
        addVariant(PluralMapBase::OTHER, "pickles", *rhs);
        addVariant(PluralMapBase::ONE, "pickle", *rhs);
        addVariant(PluralMapBase::FEW, "picklefew", *rhs);
        PluralMapForPluralMapTest lhs(*rhs);
        delete rhs;
        assertTrue("", lhs == control);
    }
    {
        PluralMapForPluralMapTest *rhs = new PluralMapForPluralMapTest();
        if (rhs == NULL) {
            errln("Memory allocation error.");
            return;
        }
        addVariant(PluralMapBase::OTHER, "pickles", *rhs);
        addVariant(PluralMapBase::ONE, "pickle", *rhs);
        addVariant(PluralMapBase::FEW, "picklefew", *rhs);
        PluralMapForPluralMapTest lhs;
        addVariant(PluralMapBase::OTHER, "pickles", lhs);
        addVariant(PluralMapBase::TWO, "pickletwo", lhs);
        addVariant(PluralMapBase::MANY, "picklemany", lhs);
        addVariant(PluralMapBase::FEW, "picklefew", lhs);
        lhs = *rhs;
        delete rhs;
        assertTrue("", lhs == control);
    }

}


void PluralMapTest::addVariant(
        PluralMapBase::Category v,
        const UnicodeString &value,
        PluralMapForPluralMapTest &map) {
    UErrorCode status = U_ZERO_ERROR;
    UnicodeString *current = map.getMutable(v, status);
    if (!assertSuccess("", status)) {
        return;
    }
    (*current) = value;
}

extern IntlTest *createPluralMapTest() {
    return new PluralMapTest();
}
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
2ca993e8 A	3	/*
	4	*******************************************************************************
	5	* Copyright (C) 2014-2015, International Business Machines Corporation and *
	6	* others. All Rights Reserved. *
	7	*******************************************************************************
	8	*
	9	* File PLURALMAPTEST.CPP
	10	*
	11	********************************************************************************
	12	*/
	13	#include "unicode/unistr.h"
	14
	15	#include "intltest.h"
	16	#include "pluralmap.h"
	17
	18	class PluralMapForPluralMapTest : public PluralMap<UnicodeString> {
	19	public:
	20	UBool operator==(const PluralMapForPluralMapTest &other) {
	21	return equals(other, strEqual);
	22	}
	23	private:
	24	static UBool strEqual(const UnicodeString &lhs, const UnicodeString &rhs) {
	25	return lhs == rhs;
	26	}
	27	};
	28
	29	class PluralMapTest : public IntlTest {
	30	public:
	31	PluralMapTest() {
	32	}
	33	void TestToCategory();
	34	void TestGetCategoryName();
	35	void TestGet();
	36	void TestIterate();
	37	void TestEqual();
	38	void TestCopyAndAssign();
	39	void runIndexedTest(int32_t index, UBool exec, const char &name, char par=0);
	40	void addVariant(
	41	PluralMapBase::Category v,
	42	const UnicodeString &value,
	43	PluralMapForPluralMapTest &map);
	44	private:
	45	};
	46
	47	void PluralMapTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /par/) {
	48	TESTCASE_AUTO_BEGIN;
	49	TESTCASE_AUTO(TestToCategory);
	50	TESTCASE_AUTO(TestGetCategoryName);
	51	TESTCASE_AUTO(TestGet);
	52	TESTCASE_AUTO(TestIterate);
	53	TESTCASE_AUTO(TestEqual);
	54	TESTCASE_AUTO(TestCopyAndAssign);
	55	TESTCASE_AUTO_END;
	56	}
	57
	58	void PluralMapTest::TestToCategory() {
f3c0d7a5 A	59	assertEquals("", (int32_t)PluralMapBase::OTHER, PluralMapBase::toCategory("other"));
	60	assertEquals("", (int32_t)PluralMapBase::ZERO, PluralMapBase::toCategory("zero"));
	61	assertEquals("", (int32_t)PluralMapBase::ONE, PluralMapBase::toCategory("one"));
	62	assertEquals("", (int32_t)PluralMapBase::TWO, PluralMapBase::toCategory("two"));
	63	assertEquals("", (int32_t)PluralMapBase::FEW, PluralMapBase::toCategory("few"));
	64	assertEquals("", (int32_t)PluralMapBase::MANY, PluralMapBase::toCategory("many"));
	65	assertEquals("", (int32_t)PluralMapBase::NONE, PluralMapBase::toCategory("Many"));
2ca993e8 A	66	assertEquals(
2ca993e8 A	67	"",
f3c0d7a5	68	(int32_t)PluralMapBase::FEW,
2ca993e8 A	69	PluralMapBase::toCategory(UnicodeString("few")));
	70	assertEquals(
	71	"",
f3c0d7a5	72	(int32_t)PluralMapBase::MANY,
2ca993e8 A	73	PluralMapBase::toCategory(UnicodeString("many")));
	74	assertEquals(
	75	"",
f3c0d7a5	76	(int32_t)PluralMapBase::NONE,
2ca993e8 A	77	PluralMapBase::toCategory(UnicodeString("Many")));
	78	}
	79
	80	void PluralMapTest::TestGetCategoryName() {
	81	assertTrue("", PluralMapBase::getCategoryName(PluralMapBase::NONE) == NULL);
	82	assertTrue("", PluralMapBase::getCategoryName(PluralMapBase::CATEGORY_COUNT) == NULL);
	83	assertEquals("", "other", PluralMapBase::getCategoryName(PluralMapBase::OTHER));
	84	assertEquals("", "zero", PluralMapBase::getCategoryName(PluralMapBase::ZERO));
	85	assertEquals("", "one", PluralMapBase::getCategoryName(PluralMapBase::ONE));
	86	assertEquals("", "two", PluralMapBase::getCategoryName(PluralMapBase::TWO));
	87	assertEquals("", "few", PluralMapBase::getCategoryName(PluralMapBase::FEW));
	88	assertEquals("", "many", PluralMapBase::getCategoryName(PluralMapBase::MANY));
	89	}
	90
	91	void PluralMapTest::TestGet() {
	92	PluralMapForPluralMapTest map;
	93	addVariant(PluralMapBase::OTHER, "pickles", map);
	94	addVariant(PluralMapBase::ONE, "pickle", map);
	95	addVariant(PluralMapBase::FEW, "picklefew", map);
	96	assertEquals("", "pickles", map.get(PluralMapBase::OTHER));
	97	assertEquals("", "pickle", map.get(PluralMapBase::ONE));
	98	assertEquals("", "picklefew", map.get(PluralMapBase::FEW));
	99	assertEquals("", "pickles", map.get(PluralMapBase::MANY));
	100	assertEquals("", "pickles", map.get(PluralMapBase::NONE));
	101	assertEquals("", "pickles", map.get(PluralMapBase::CATEGORY_COUNT));
	102	assertEquals("", "picklefew", map.get("few"));
	103	assertEquals("", "pickles", map.get("many"));
	104	assertEquals("", "pickles", map.get("somebadform"));
	105	assertEquals("", "pickle", map.get(UnicodeString("one")));
	106	assertEquals("", "pickles", map.get(UnicodeString("many")));
	107	assertEquals("", "pickles", map.get(UnicodeString("somebadform")));
	108	assertEquals("", "pickles", map.getOther());
	109	}
	110
	111	void PluralMapTest::TestIterate() {
	112	PluralMapForPluralMapTest map;
	113	addVariant(PluralMapBase::OTHER, "pickles", map);
	114	addVariant(PluralMapBase::ONE, "pickle", map);
	115	addVariant(PluralMapBase::FEW, "pickleops", map);
	116	addVariant(PluralMapBase::FEW, "picklefew", map);
	117	PluralMapBase::Category index = PluralMapBase::NONE;
	118	const UnicodeString *current = map.next(index);
	119	assertEquals("", "pickles", *current);
f3c0d7a5	120	assertEquals("", (int32_t)PluralMapBase::OTHER, index);
2ca993e8 A	121	current = map.next(index);
2ca993e8 A	122	assertEquals("", "pickle", *current);
f3c0d7a5	123	assertEquals("", (int32_t)PluralMapBase::ONE, index);
2ca993e8 A	124	current = map.next(index);
2ca993e8 A	125	assertEquals("", "picklefew", *current);
f3c0d7a5	126	assertEquals("", (int32_t)PluralMapBase::FEW, index);
2ca993e8	127	current = map.next(index);
f3c0d7a5	128	assertEquals("", (int32_t)PluralMapBase::CATEGORY_COUNT, index);
2ca993e8 A	129	assertTrue("", current == NULL);
	130
	131	PluralMapForPluralMapTest map2;
	132	index = PluralMapBase::NONE;
	133	current = map2.next(index);
	134	assertEquals("", "", *current);
f3c0d7a5	135	assertEquals("", (int32_t)PluralMapBase::OTHER, index);
2ca993e8	136	current = map2.next(index);
f3c0d7a5	137	assertEquals("", (int32_t)PluralMapBase::CATEGORY_COUNT, index);
2ca993e8 A	138	assertTrue("", current == NULL);
	139	}
	140
	141	void PluralMapTest::TestEqual() {
	142	PluralMapForPluralMapTest control;
	143	addVariant(PluralMapBase::OTHER, "pickles", control);
	144	addVariant(PluralMapBase::ONE, "pickle", control);
	145	addVariant(PluralMapBase::FEW, "picklefew", control);
	146
	147	{
	148	PluralMapForPluralMapTest map;
	149	addVariant(PluralMapBase::FEW, "picklefew", map);
	150	addVariant(PluralMapBase::OTHER, "pickles", map);
	151	addVariant(PluralMapBase::ONE, "pickle", map);
	152	assertTrue("", control == map);
	153	addVariant(PluralMapBase::ONE, "pickl", map);
	154	assertFalse("", control == map);
	155	}
	156	{
	157	PluralMapForPluralMapTest map;
	158	addVariant(PluralMapBase::MANY, "picklemany", map);
	159	addVariant(PluralMapBase::OTHER, "pickles", map);
	160	addVariant(PluralMapBase::ONE, "pickle", map);
	161	assertFalse("", control == map);
	162	}
	163	}
	164
	165	void PluralMapTest::TestCopyAndAssign() {
	166	PluralMapForPluralMapTest control;
	167	addVariant(PluralMapBase::OTHER, "pickles", control);
	168	addVariant(PluralMapBase::ONE, "pickle", control);
	169	addVariant(PluralMapBase::FEW, "picklefew", control);
	170	{
	171	PluralMapForPluralMapTest *rhs = new PluralMapForPluralMapTest();
	172	if (rhs == NULL) {
	173	errln("Memory allocation error.");
	174	return;
	175	}
	176	addVariant(PluralMapBase::OTHER, "pickles", *rhs);
	177	addVariant(PluralMapBase::ONE, "pickle", *rhs);
	178	addVariant(PluralMapBase::FEW, "picklefew", *rhs);
	179	PluralMapForPluralMapTest lhs(*rhs);
	180	delete rhs;
	181	assertTrue("", lhs == control);
	182	}
	183	{
	184	PluralMapForPluralMapTest *rhs = new PluralMapForPluralMapTest();
	185	if (rhs == NULL) {
	186	errln("Memory allocation error.");
	187	return;
	188	}
	189	addVariant(PluralMapBase::OTHER, "pickles", *rhs);
	190	addVariant(PluralMapBase::ONE, "pickle", *rhs);
	191	addVariant(PluralMapBase::FEW, "picklefew", *rhs);
	192	PluralMapForPluralMapTest lhs;
	193	addVariant(PluralMapBase::OTHER, "pickles", lhs);
	194	addVariant(PluralMapBase::TWO, "pickletwo", lhs);
	195	addVariant(PluralMapBase::MANY, "picklemany", lhs);
	196	addVariant(PluralMapBase::FEW, "picklefew", lhs);
	197	lhs = *rhs;
	198	delete rhs;
	199	assertTrue("", lhs == control);
	200	}
	201
202	}
203
204
205
206	void PluralMapTest::addVariant(
207	PluralMapBase::Category v,
208	const UnicodeString &value,
209	PluralMapForPluralMapTest &map) {
210	UErrorCode status = U_ZERO_ERROR;
211	UnicodeString *current = map.getMutable(v, status);
212	if (!assertSuccess("", status)) {
213	return;
214	}
215	(*current) = value;
216	}
217
218	extern IntlTest *createPluralMapTest() {
219	return new PluralMapTest();
220	}