#
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description: 
#
# Unit test for raptor_cache module

import generic_path
import os.path
import raptor
import raptor_cache
import unittest

class TestRaptorCache(unittest.TestCase):

	def setUp(self):
		self.raptor = raptor.Raptor()
		self.cache = self.raptor.cache

		dir = self.raptor.home.Append("test", "config")
		self.cache.Load(dir)
		
	def testLoadSingle(self):
		# load a single XML file
		file = self.raptor.home.Append("test/unit_suite/data", raptor.xml)
		self.cache.Load(file)
		self.failUnless(len(self.cache.variants) > 0)
		self.failUnless(len(self.cache.aliases) > 0)
		self.failUnless(len(self.cache.groups) > 0)
		
	def testVariant(self):
		def _testSingleVariant(name):
			try:
				var = self.cache.FindNamedVariant(name)
			except KeyError:
				self.fail()
			else:
				self.failUnless(var)
				self.assertEqual(var.name, name)

		_testSingleVariant("ARMV5_BASE")
		_testSingleVariant("ARMV5_UREL")
		_testSingleVariant("ARMV5_UDEB")
		_testSingleVariant("MOD1")
		_testSingleVariant("MOD2")
		_testSingleVariant("var_redef")

		self.failUnlessRaises( KeyError, self.cache.FindNamedVariant, "XY_123" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedVariant, "ARMV5" )

	def testAlias(self):
		def _testSingleAlias(name):
			try:
				alias = self.cache.FindNamedAlias(name)
			except KeyError:
				self.fail()
			else:
				self.failUnless(alias)
				self.assertEqual(alias.name, name)

		_testSingleAlias("ALIAS_1")
		_testSingleAlias("ALIAS_2")
		_testSingleAlias("alias_redef")

		self.failUnlessRaises( KeyError, self.cache.FindNamedAlias, "XY_123" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedAlias, "ARMV5" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedAlias, "ARMV5_UREL" )

	def testGroup(self):
		def _testSingleGroup(name):
			try:
				group = self.cache.FindNamedGroup(name)
			except KeyError:
				self.fail()
			else:
				self.failUnless(group)
				self.assertEqual(group.name, name)
				
		_testSingleGroup("ARMV5")
		_testSingleGroup("group_redef")

		self.failUnlessRaises( KeyError, self.cache.FindNamedGroup, "XY_123" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedGroup, "ARMV5_UDEB" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedGroup, "ARMV5_UREL" )

	def testInterface(self):
		def _testSingleInterface(name):
			try:
				interface = self.cache.FindNamedInterface(name)
			except KeyError:
				self.fail()
			else:
				self.failUnless(interface)
				self.assertEqual(interface.name, name)
				
		_testSingleInterface("interface_redef")

		self.failUnlessRaises( KeyError, self.cache.FindNamedInterface, "foo" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedInterface, "bar" )
		self.failUnlessRaises( KeyError, self.cache.FindNamedInterface, "123" )

	def testLoadLegacy(self):
		# load some schema 1.0 XML files
		dir = self.raptor.home.Append("test/unit_suite/data")
		self.cache.Load(dir)
		try:
			self.cache.FindNamedInterface("base.1_0")
			self.cache.FindNamedInterface("interface.1_0")
			self.cache.FindNamedVariant("var1_0")
			self.cache.FindNamedAlias("alias1_0")
		except KeyError:
			self.fail()

		self.failUnlessRaises( KeyError, self.cache.FindNamedVariant, "should_be_ignored" )
		
# run all the tests

from raptor_tests import SmokeTest

def run():
	t = SmokeTest()
	t.id = "999"
	t.name = "raptor_cache_unit"

	tests = unittest.makeSuite(TestRaptorCache)
	result = unittest.TextTestRunner(verbosity=2).run(tests)

	if result.wasSuccessful():
		t.result = SmokeTest.PASS
	else:
		t.result = SmokeTest.FAIL

	return t