#
# 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 tests for the raptor module

import raptor
import raptor_version
import raptor_meta
import raptor_utilities
import re
import unittest
import generic_path
import tempfile
import os

class TestRaptor(unittest.TestCase):

	def testConstructor(self):
		r = raptor.Raptor()
		self.failUnless(r)


	def testHome(self):
		r = raptor.Raptor()
		self.failUnless(r.home)
		r = raptor.Raptor("dirname")
		self.failUnless(r.errorCode == 1) # picked up that dirname doesn't exist
		

	def testVersion(self):
		self.failUnless(re.match("^\d+\.\d+\.", raptor_version.fullversion()))


	def testCLISupport(self):
		r = raptor.Raptor()
		r.RunQuietly(True)
		r.AddConfigName("tom")
		r.AddConfigName("dick")
		r.AddConfigName("harry")
		r.SetEnv("ROOT", "/a/b/c")
		r.SetEnv("TREE", "beech")
		r.SetJobs(4)
		r.AddProject("foo.mmp")
		r.AddProject("bar.mmp")
		r.SetSysDefFile("SysDef.xml")
		r.SetSysDefBase("C:\\mysysdef")
		r.AddBuildInfoFile("build.info")
		r.SetTopMakefile("E:\\epoc32\\build\\Makefile")
		
		
	def testComponentListParsing(self):
		expected_spec_output = [
				'test/smoke_suite/test_resources/simple/bld.inf',
				'test/smoke_suite/test_resources/simple_export/bld.inf',
				'test/smoke_suite/test_resources/simple_dll/bld.inf',
				'test/smoke_suite/test_resources/simple_extension/bld.inf',
				'test/smoke_suite/test_resources/simple_gui/Bld.inf',
				'TOOLS2 SHOULD NOT APPEAR IN THE OUTPUT']
		
		r = raptor.Raptor()
		null_log_instance = raptor_utilities.NullLog()
		r.Info = null_log_instance.Info 
		r.Debug = null_log_instance.Debug
		r.Warn = null_log_instance.Warn
		r.ConfigFile()
		r.ProcessConfig()
		# Note that tools2/bld.inf specifies tools2 as the only supported
		# platform, so it should not appear in the component list at the end
		r.CommandLine([
				'-b', 'smoke_suite/test_resources/simple/bld.inf',
				'-b', 'smoke_suite/test_resources/simple_dll/bld.inf',
				'-b', 'smoke_suite/test_resources/simple_export/bld.inf',
				'-b', 'smoke_suite/test_resources/simple_extension/bld.inf',
				'-b', 'smoke_suite/test_resources/simple_gui/Bld.inf',
				'-b', 'smoke_suite/test_resources/tools2/bld.inf',
				'-c', 'armv5'])
		# establish an object cache
		r.LoadCache()
		buildUnitsToBuild = r.GetBuildUnitsToBuild(r.configNames)
		# find out what components to build, and in what way
		layers = []
		layers = r.GetLayersFromCLI()
		
		generic_specs = r.GenerateGenericSpecs(buildUnitsToBuild)
		
		specs = []
		specs.extend(generic_specs)
		metaReader = raptor_meta.MetaReader(r, buildUnitsToBuild)
		specs.extend(metaReader.ReadBldInfFiles(layers[0].children,
				False))

		# See what components are actually built for the given configs
		# should be only 5 since 1 is a tools component and we're building armv5
		hits = 0
		for c in layers[0].children:
			if len(c.specs) > 0: 
				# something will be built from this component because
				# it has at least one spec
				shortname = str(c.bldinf_filename)[len(os.environ['SBS_HOME'])+1:]
				self.assertTrue(shortname in expected_spec_output)
				hits += 1

		# Ensure there actually are 5 build specs
		self.assertEqual(hits, len(expected_spec_output) - 1)


	def setUp(self):
		self.r = raptor.Raptor()
		
		self.cwd = generic_path.CurrentDir()
		self.isFileReturningFalse = lambda: False
		self.isFileReturningTrue = lambda: True
		
		self.sysDef = self.cwd.Append(self.r.systemDefinition)
		self.bldInf = self.cwd.Append(self.r.buildInformation)

	def testWarningIfSystemDefinitionFileDoesNotExist(self): 
		"""Test if sbs creates warning if executed without specified 
		component to build i.e. default bld.inf (bld.inf in current 
		directory) or system definition file.

		Uses an empty temporary directory for this."""
		self.r.out = OutputMock()

		d = tempfile.mkdtemp(prefix='raptor_test') 
		cdir = os.getcwd()
		os.chdir(d) 
		layers = self.r.GetLayersFromCLI()
		os.chdir(cdir) # go back
		os.rmdir(d)
		
		self.assertTrue(self.r.out.warningWritten())

		d = tempfile.mkdtemp(prefix='raptor_test') 
		cdir = os.getcwd()
		os.chdir(d)
		f = open("bld.inf","w")
		f.close()
		layers = self.r.GetLayersFromCLI()
		os.unlink("bld.inf")
		os.chdir(cdir) # go back
		os.rmdir(d)

		self.assertTrue(self.r.out.warningWritten())

	def testNoWarningIfSystemDefinitionFileExists(self): 
		self.r.out = OutputMock()

		d = tempfile.mkdtemp(prefix='raptor_test') 
		cdir = os.getcwd()
		os.chdir(d)
		f = open("System_Definition.xml","w")
		f.close()
		layers = self.r.GetLayersFromCLI()
		os.unlink("System_Definition.xml")
		os.chdir(cdir) # go back
		os.rmdir(d)

		self.assertFalse(self.r.out.warningWritten())
	
	# Test Info, Warn & Error functions can handle attributes
	def testInfoAttributes(self):
		self.r.out = OutputMock()
		self.r.Info("hello %s", "world", planet="earth")
		expected = "<info planet='earth'>hello world</info>\n"
		self.assertEquals(self.r.out.actual, expected)
		
	def testWarnAttributes(self):
		self.r.out = OutputMock()
		self.r.Warn("look out", where="behind you")
		expected = "<warning where='behind you'>look out</warning>\n"
		self.assertEquals(self.r.out.actual, expected)
		
	def testErrorAttributes(self):
		self.r.out = OutputMock()
		self.r.Error("messed up %s and %s", "all", "sundry", bldinf="bld.inf")
		expected = "<error bldinf='bld.inf'>messed up all and sundry</error>\n"
		self.assertEquals(self.r.out.actual, expected)	
		
	# Test Info, Warn & Error functions to ensure XML control chars are escaped
	def testInfoXMLEscaped(self):
		self.r.out = OutputMock()
		self.r.Info("h&l>o<&amp;")
		expected = "<info>h&amp;l&gt;o&lt;&amp;amp;</info>\n"
		self.assertEquals(self.r.out.actual, expected)
		
	def testWarnXMLEscaped(self):
		self.r.out = OutputMock()
		self.r.Warn("h&l>o<&amp;")
		expected = "<warning>h&amp;l&gt;o&lt;&amp;amp;</warning>\n"
		self.assertEquals(self.r.out.actual, expected)
		
	def testErrorXMLEscaped(self):
		self.r.out = OutputMock()
		self.r.Error("h&l>o<&amp;")
		expected = "<error>h&amp;l&gt;o&lt;&amp;amp;</error>\n"
		self.assertEquals(self.r.out.actual, expected)
	
		
# Mock output class preserving output for checking
# Can also check if any warning has been written
class OutputMock(object):
	warningRegExp = re.compile(".*warning.*")

	def __init__(self):
		self.actual = ""
	
	def write(self, text):
		self.actual += text
		
	def warningWritten(self):
		if OutputMock.warningRegExp.match(self.actual):
			return True
		return False
			
# run all the tests

from raptor_tests import SmokeTest

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

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

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

	return t