configurationengine/source/plugins/symbian/ConeHCRPlugin/hcrplugin/tests/unittest_reader.py
Adding EPL version of configurationengine.
#
# 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 "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:
#
import os, unittest
import __init__
from testautomation.utils import hex_to_bindata
from hcrplugin.hcr_reader import HcrReader
from hcrplugin import hcr_exceptions
from hcrplugin.hcrrepository import HcrRecord
class TestHcrReader(unittest.TestCase):
def setUp(self):
self.reader = HcrReader()
def test_read_repo_with_invalid_record_section_size(self):
# Record section size: 4 * 20 = 80
# LSD offset: 32 + 80 = 112
# LSD size: 0
data = [
# Header
# Record count should be 4, but is 6 here
"48435266 0200 0300 06000000 70000000",
"00000000 000000000000000000000000",
# Record section
"01000000 01000000 08000000 0000 0000 01000000", # bool
"02000000 01000000 04000000 0000 0000 85FFFFFF", # int8
"03000000 01000000 40000000 0000 0000 CC000000", # uint8
"01000000 02000000 02000000 0000 0000 91CBFFFF", # int16
]
data = ''.join(map(lambda x: hex_to_bindata(x), data))
try:
self.reader.parse_repository_from_bindata(data)
self.fail("Expected exception not raised")
except hcr_exceptions.InvalidHcrDataSizeError:
pass
def test_read_repo_with_invalid_lsd_section_size(self):
# Record section size: 4 * 20 = 80
# LSD offset: 32 + 80 = 112
# LSD size: 0
data = [
# Header
# LSD section size should be 0, but is 40 here
"48435266 0200 0300 04000000 70000000",
"28000000 000000000000000000000000",
# Record section
"01000000 01000000 08000000 0000 0000 01000000", # bool
"02000000 01000000 04000000 0000 0000 85FFFFFF", # int8
"03000000 01000000 40000000 0000 0000 CC000000", # uint8
"01000000 02000000 02000000 0000 0000 91CBFFFF", # int16
]
data = ''.join(map(lambda x: hex_to_bindata(x), data))
try:
self.reader.parse_repository_from_bindata(data)
self.fail("Expected exception not raised")
except hcr_exceptions.InvalidHcrDataSizeError:
pass
def test_read_repo_with_invalid_lsd_section_offset(self):
# Record section size: 2 * 20 = 40
# LSD offset: 32 + 40 = 72
# LSD size: 8 + 8 = 16
data = [
# Header, LSD offset here is 60
"48435266 0200 0300 02000000 3C000000",
"10000000 000000000000000000000000",
# Record section
"01000000 01000000 00000001 0000 0800 00000000", # int64, lsd pos = (0, 8)
"02000000 01000000 00000002 0000 0800 08000000", # uint64, lsd pos = (8, 8)
# LSD section
"FC73 978B B823 D47F", # 8 bytes
"14FD 32B4 F410 2295", # 8 bytes
]
data = ''.join(map(lambda x: hex_to_bindata(x), data))
try:
self.reader.parse_repository_from_bindata(data)
self.fail("Expected exception not raised")
except hcr_exceptions.InvalidLsdSectionOffsetError:
pass
def test_read_repo_with_invalid_lsd_pos_in_record(self):
# Record section size: 2 * 20 = 40
# LSD offset: 32 + 40 = 72
# LSD size: 8 + 8 = 16
data = [
# Header
"48435266 0200 0300 02000000 48000000",
"10000000 000000000000000000000000",
# Record section
"01000000 01000000 00000001 0000 0800 00000000", # int64, lsd pos = (0, 8)
"02000000 01000000 00000002 0000 0800 0C000000", # uint64, lsd pos = (12, 8), should be (8, 8)
# LSD section
"FC73 978B B823 D47F", # 8 bytes
"14FD 32B4 F410 2295", # 8 bytes
]
data = ''.join(map(lambda x: hex_to_bindata(x), data))
try:
self.reader.parse_repository_from_bindata(data)
self.fail("Expected exception not raised")
except hcr_exceptions.InvalidRecordLsdPositionError:
pass
def test_read_repo_with_invalid_record_value_type(self):
# Record section size: 2 * 20 = 40
# LSD offset: 32 + 40 = 72
# LSD size: 8 + 8 = 16
data = [
# Header
"48435266 0200 0300 02000000 48000000",
"10000000 000000000000000000000000",
# Record section
"01000000 01000000 00000001 0000 0800 00000000", # int64, lsd pos = (0, 8)
"02000000 01000000 DEADBEEF 0000 0800 0C000000", # invalid type
# LSD section
"FC73 978B B823 D47F", # 8 bytes
"14FD 32B4 F410 2295", # 8 bytes
]
data = ''.join(map(lambda x: hex_to_bindata(x), data))
try:
self.reader.parse_repository_from_bindata(data)
self.fail("Expected exception not raised")
except hcr_exceptions.InvalidRecordValueTypeError:
pass
def _run_test_read_record_with_invalid_lsd_size(self, value_type, lsd_data):
try:
self.reader.parse_record_value_from_lsd_bindata(value_type, lsd_data)
self.fail("Expected exception not raised")
except hcr_exceptions.InvalidRecordLsdPositionError:
pass
def test_read_record_with_invalid_lsd_size_int64(self):
data = hex_to_bindata("0000 0000 0000 00")
self._run_test_read_record_with_invalid_lsd_size(HcrRecord.VALTYPE_INT64, data)
def test_read_record_with_invalid_lsd_size_uint64(self):
data = hex_to_bindata("0000 0000 0000 00")
self._run_test_read_record_with_invalid_lsd_size(HcrRecord.VALTYPE_UINT64, data)
def test_read_record_with_invalid_lsd_size_arrayint32(self):
data = hex_to_bindata("0000 0000 0000 00")
self._run_test_read_record_with_invalid_lsd_size(HcrRecord.VALTYPE_ARRAY_INT32, data)
def test_read_record_with_invalid_lsd_size_arrayuint32(self):
data = hex_to_bindata("0000 0000 0000 00")
self._run_test_read_record_with_invalid_lsd_size(HcrRecord.VALTYPE_ARRAY_UINT32, data)
def test_read_record_with_invalid_data_size(self):
try:
self.reader.parse_record_from_bindata('1234')
self.fail("Parsing invalid record data succeeded!")
except hcr_exceptions.HcrReaderError:
pass
def test_read_signed_integer_in_record(self):
#Test that padding bytes don't matter when reading the type
def check(record, data):
self.assertEquals(self.reader.parse_record_from_bindata(data)[0], record)
r = HcrRecord(HcrRecord.VALTYPE_INT8, -123, 12, 43, 5)
d = hex_to_bindata("0C000000 2B000000 04000000 0500 0000 85FFFFFF")
check(r, d)
d = hex_to_bindata("0C000000 2B000000 04000000 0500 0000 85000000")
check(r, d)
r = HcrRecord(HcrRecord.VALTYPE_INT16, -12345, 12, 43, 5)
d = hex_to_bindata("0C000000 2B000000 02000000 0500 0000 C7CFFFFF")
check(r, d)
d = hex_to_bindata("0C000000 2B000000 02000000 0500 0000 C7CF0000")
check(r, d)