haiku.git

/*
 * Copyright 2019 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 * 		Simon South, simon@simonsouth.net
 */


#include <stdio.h>
#include <string.h>

#include <map>

#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>

#include "KeymapTest.h"


KeymapTest::KeymapTest()
{
	fCurrentKeymap.SetToCurrent();
	fDefaultKeymap.SetToDefault();
}


KeymapTest::~KeymapTest()
{
}


void
KeymapTest::TestEquals()
{
	CPPUNIT_ASSERT(fCurrentKeymap == fCurrentKeymap);
	CPPUNIT_ASSERT(fDefaultKeymap == fDefaultKeymap);

	BKeymap keymap;

	keymap.SetToCurrent();
	CPPUNIT_ASSERT(keymap == fCurrentKeymap);

	keymap.SetToDefault();
	CPPUNIT_ASSERT(keymap == fDefaultKeymap);
}


void
KeymapTest::TestAssignment()
{
	BKeymap keymap;

	keymap = fCurrentKeymap;
	CPPUNIT_ASSERT(keymap == fCurrentKeymap);

	keymap = fDefaultKeymap;
	CPPUNIT_ASSERT(keymap == fDefaultKeymap);
}


void
KeymapTest::TestGetChars()
{
	// Get a copy of the currently loaded keymap
	key_map* keymap;
	char* charArray;

	get_key_map(&keymap, &charArray);
	CPPUNIT_ASSERT(keymap != NULL);

	// Test each of the keymap's character tables
	typedef std::map<uint32, int32(*)[128]> table_map_t;
	table_map_t tables;
	tables[0] = &keymap->normal_map;
	tables[B_SHIFT_KEY] = &keymap->shift_map;
	tables[B_CAPS_LOCK] = &keymap->caps_map;
	tables[B_CAPS_LOCK | B_SHIFT_KEY] = &keymap->caps_shift_map;
	tables[B_CONTROL_KEY] = &keymap->control_map;
	tables[B_OPTION_KEY] = &keymap->option_map;
	tables[B_OPTION_KEY | B_SHIFT_KEY] = &keymap->option_shift_map;
	tables[B_OPTION_KEY | B_CAPS_LOCK] = &keymap->option_caps_map;
	tables[B_OPTION_KEY | B_SHIFT_KEY | B_CAPS_LOCK] =
		&keymap->option_caps_shift_map;

	for (table_map_t::const_iterator p = tables.begin();
		 p != tables.end(); p++) {
		const uint32 modifiers = (*p).first;
		const int32(*table)[128] = (*p).second;

		// Test, for every keycode, that the result from BKeymap::GetChars()
		// matches what we find in our our own copy of the keymap
		for (uint32 keycode = 0; keycode < 128; keycode++) {
			char* mapChars = &charArray[(*table)[keycode]];

			// If the keycode isn't mapped, try again without the Option key
			if (*mapChars <= 0 && (modifiers & B_OPTION_KEY) != 0) {
				int newOffset = (*tables[modifiers & ~B_OPTION_KEY])[keycode];
				if (newOffset >= 0)
					mapChars = &charArray[newOffset];
			}

			char* chars;
			int32 numBytes;
			fCurrentKeymap.GetChars(keycode, modifiers, 0, &chars, &numBytes);

			CPPUNIT_ASSERT(*mapChars <= 0 || chars != NULL);
			CPPUNIT_ASSERT_EQUAL(*mapChars, numBytes);
			CPPUNIT_ASSERT(strncmp(chars, mapChars + 1, numBytes) == 0);
		}
	}

	delete keymap;
	delete[] charArray;
}


/* static */ void
KeymapTest::AddTests(BTestSuite& parent)
{
	CppUnit::TestSuite& suite = *new CppUnit::TestSuite("KeymapTest");

	suite.addTest(new CppUnit::TestCaller<KeymapTest>(
		"KeymapTest::TestEquals", &KeymapTest::TestEquals));
	suite.addTest(new CppUnit::TestCaller<KeymapTest>(
		"KeymapTest::TestAssignment", &KeymapTest::TestAssignment));
	suite.addTest(new CppUnit::TestCaller<KeymapTest>(
		"KeymapTest::TestGetChars", &KeymapTest::TestGetChars));

	parent.addTest("KeymapTest", &suite);
}