#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright 2015 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import csv
import os
import tempfile
import unittest

from . import testplan

class SampleTestPlanTest(unittest.TestCase):
  def testLoadSampleTestPlan(self):
    sample_file = 'sample_testplan.csv'
    test_plan = testplan.TestPlan(sample_file)
    self.assertTrue(len(test_plan) > 0)


class WLANTestPlanTest(unittest.TestCase):
  def setUp(self):
    self.temp_path = tempfile.mktemp(suffix='.csv', prefix='testplan_')
    self.test_plan = testplan.TestPlan()

    self.valid_args = [
        '@title', 'component_name', 'rf_type', 'test_type', 'center_freq',
        'power_level', 'standard', 'bandwidth', 'data_rate', 'chain_mask',
        'nss', 'long_preamble']
    self.valid_args_value = [
        '', 'WLAN_2G', 'WLAN', 'TX', '[2412, 2437]',
        '18', 'B', '20', '1', '[1, 2]',
        'None', '0']
    self.valid_results = [
        '@result', 'evm', 'avg_power', 'freq_error', 'lo_leakage',
        'mask_margin', 'spectral_flatness', 'obw', 'phase_noise']
    self.valid_result_value = [
        '', '(None,-25)', '(16,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)', '(0,20)', '(-20,20)']

  def tearDown(self):
    if os.path.exists(self.temp_path):
      os.remove(self.temp_path)

  def _WriteCSVContent(self, content):
    with open(self.temp_path, 'w') as f:
      writer = csv.writer(f)
      writer.writerows(content)

  def testCommentedContent(self):
    self._WriteCSVContent([
        ['#', 'This is comment'],
        ['#This is also comment', 'hello world'],
        [' # We will ignore the space at the beginning', 'yeah!!'],
        self.valid_args + self.valid_results,
        self.valid_args_value + self.valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(4, len(self.test_plan))

  def testParseValidWLANContent(self):
    self._WriteCSVContent([
        self.valid_args + self.valid_results,
        self.valid_args_value + self.valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(4, len(self.test_plan))

  def testMissingArgumentTitle(self):
    invalid_args = self.valid_args[:-1]
    invalid_args_value = self.valid_args_value[:-1]
    self._WriteCSVContent([
        invalid_args + self.valid_results,
        invalid_args_value + self.valid_result_value])

    with self.assertRaisesRegexp(ValueError, 'missing'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testWrongArgumentTitle(self):
    self._WriteCSVContent([
        self.valid_args + ['wrong_arg'] + self.valid_results,
        self.valid_args_value + ['WRONG_VALUE'] + self.valid_result_value])

    with self.assertRaisesRegexp(ValueError, 'wrong_arg'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testWrongResultTitle(self):
    self._WriteCSVContent([
        self.valid_args + self.valid_results + ['wrong_result'],
        self.valid_args_value + self.valid_result_value + ['WRONG_VALUE']])

    with self.assertRaisesRegexp(ValueError, 'wrong_result'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testMissingResultTitle(self):
    self._WriteCSVContent([
        self.valid_args,
        self.valid_args_value])

    with self.assertRaisesRegexp(ValueError, '@result'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testWrongArgumentValue(self):
    # Wrong value for rf_type
    wrong_args_value = self.valid_args_value[:]
    wrong_args_value[2] = 'WRONG_RF_TYPE'
    self._WriteCSVContent([
        self.valid_args + self.valid_results,
        wrong_args_value + self.valid_result_value])

    with self.assertRaisesRegexp(ValueError, 'WRONG_RF_TYPE'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testWrongArgumentValueInList(self):
    # Wrong valud for center_freq
    wrong_args_value = self.valid_args_value[:]
    wrong_args_value[4] = '[2412, WRONG_VALUE]'
    self._WriteCSVContent([
        self.valid_args + self.valid_results,
        wrong_args_value + self.valid_result_value])

    with self.assertRaisesRegexp(ValueError, 'WRONG_VALUE'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(2, len(self.test_plan))

  def testWrongResultValue(self):

    self._WriteCSVContent([
        self.valid_args + ['@result', 'avg_power'],
        self.valid_args_value + ['', 'WRONG_RESULT']])

    with self.assertRaisesRegexp(ValueError, 'WRONG_RESULT'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testMissingValue(self):
    self._WriteCSVContent([
        self.valid_args + self.valid_results,
        self.valid_args_value])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testMissingTitle(self):
    self._WriteCSVContent([
        self.valid_args_value + self.valid_result_value])

    with self.assertRaisesRegexp(ValueError, 'title'):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testParseValidTestplanConfig(self):
    self._WriteCSVContent([
        ['@config', 'KEY', 'VALUE1']])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals('VALUE1', self.test_plan.test_config['KEY'])

  def testParseWrongConfigExtraArgument(self):
    self._WriteCSVContent([
        ['@config', 'KEY', 'VALUE1', 'EXTRA_ARG']])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)

  def testParseWrongConfigMissingValue(self):
    self._WriteCSVContent([
        ['@config', 'KEY']])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)


class BluetoothTestPlanTest(unittest.TestCase):
  def setUp(self):
    self.temp_path = tempfile.mktemp(suffix='.csv', prefix='testplan_')
    self.test_plan = testplan.TestPlan()

    self.valid_args = [
        '@title', 'component_name', 'rf_type', 'test_type', 'center_freq',
        'power_level', 'packet_type']

  def tearDown(self):
    if os.path.exists(self.temp_path):
      os.remove(self.temp_path)

  def _WriteCSVContent(self, content):
    with open(self.temp_path, 'w') as f:
      writer = csv.writer(f)
      writer.writerows(content)

  def testBDRValidValue(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '[2412, 2437]',
        '18', '1DH5']
    valid_results = [
        '@result', 'bandwidth_20db', 'delta_f2_f1_avg_ratio']
    valid_result_value = [
        '', '(16,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertTrue(len(self.test_plan) > 0)

  def testEDRValidValue(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '[2412, 2437]',
        '18', '3DH5']
    valid_results = [
        '@result', 'edr_evm_avg', 'edr_evm_peak', 'edr_extreme_omega_0',
        'edr_extreme_omega_i0', 'edr_omega_i', 'edr_power_diff',
        'edr_prob_evm_99_pass']
    valid_result_value = [
        '', '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,2)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertTrue(len(self.test_plan) > 0)

  def testLEValidValue(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '[2412, 2437]',
        '18', 'LE']
    valid_results = [
        '@result', 'freq_offset', 'delta_f0_fn_max', 'delta_f1_avg',
        'delta_f1_f0', 'delta_f2_f1_avg_ratio', 'delta_f2_avg', 'delta_f2_max',
        'delta_fn_fn5_max']
    valid_result_value = [
        '', '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertTrue(len(self.test_plan) > 0)

  def testBDRInvalidValue(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '[2412, 2437]',
        '18', '1DH5']
    invalid_results = [
        '@result', 'edr_evm_avg', 'freq_offset']
    invalid_result_value = [
        '', '(16,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + invalid_results,
        valid_args_value + invalid_result_value])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testEDRInvalidValue(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '[2412, 2437]',
        '18', '2DH5']
    invalid_results = [
        '@result', 'bandwidth_20db', 'freq_offset']
    invalid_result_value = [
        '', '(16,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + invalid_results,
        valid_args_value + invalid_result_value])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testLEInvalidValue(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '[2412, 2437]',
        '18', 'LE']
    invalid_results = [
        '@result', 'bandwidth_20db', 'edr_evm_avg']
    invalid_result_value = [
        '', '(16,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + invalid_results,
        valid_args_value + invalid_result_value])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testBDRBitPatternPRBS9(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', '1DH5']
    valid_results = [
        '@result', 'avg_power', 'bandwidth_20db', 'acp_5', 'acp_4',
        'acp_3', 'acp_2', 'acp_1', 'acp0', 'acp1',
        'acp2', 'acp3', 'acp4', 'acp5']
    valid_result_value = [
        '', '(16,20)', '(0,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)', '(0,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('PRBS9', self.test_plan[0].args['bit_pattern'])

  def testEDRBitPatternPRBS9(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', '2DH5']
    valid_results = [
        '@result', 'avg_power', 'freq_deviation', 'edr_evm_avg', 'edr_evm_peak',
        'edr_extreme_omega_0', 'edr_extreme_omega_i0', 'edr_omega_i',
        'edr_power_diff', 'edr_prob_evm_99_pass']
    valid_result_value = [
        '', '(16,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('PRBS9', self.test_plan[0].args['bit_pattern'])

  def testLEBitPatternPRBS9(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', 'LE']
    valid_results = [
        '@result', 'avg_power', 'freq_offset', 'acp_5', 'acp_4',
        'acp_3', 'acp_2', 'acp_1', 'acp0', 'acp1',
        'acp2', 'acp3', 'acp4', 'acp5']
    valid_result_value = [
        '', '(16,20)', '(0,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)', '(0,20)', '(0,20)', '(0,20)',
        '(0,20)', '(0,20)', '(0,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('PRBS9', self.test_plan[0].args['bit_pattern'])

  def testBDRBitPatternF0(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', '1DH5']
    valid_results = [
        '@result', 'delta_f1_avg', 'freq_deviation']
    valid_result_value = [
        '', '(0,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('F0', self.test_plan[0].args['bit_pattern'])

  def testLEBitPatternF0(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', 'LE']
    valid_results = [
        '@result', 'delta_f1_avg']
    valid_result_value = [
        '', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('F0', self.test_plan[0].args['bit_pattern'])

  def testBDRBitPatternAA(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', '1DH5']
    valid_results = [
        '@result', 'freq_drift', 'delta_f2_avg', 'delta_f2_max']
    valid_result_value = [
        '', '(16,20)', '(16,20)', '(16,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('AA', self.test_plan[0].args['bit_pattern'])

  def testLEBitPatternAA(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', 'LE']
    valid_results = [
        '@result', 'delta_f2_avg', 'delta_f2_max', 'delta_f1_f0',
        'delta_f0_fn_max', 'delta_fn_fn5_max']
    valid_result_value = [
        '', '(16,20)', '(0,20)', '(16,20)',
        '(0,20)', '(16,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))
    self.assertEquals('AA', self.test_plan[0].args['bit_pattern'])

  def testSplitByBitPattern(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', 'LE']
    valid_results = [
        '@result', 'avg_power',  # bit_pattern is PRBS9
        'delta_f1_avg',  # bit_pattern is F0
        'delta_f2_avg', 'delta_f2_max']  # bit_pattern is AA
    valid_result_value = [
        '', '(16,20)', '(16,20)', '(0,20)', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(3, len(self.test_plan))
    self.assertEquals(set(['PRBS9', 'F0', 'AA']),
                      set(test.args['bit_pattern'] for test in self.test_plan))

  def testDeltaF2F1Avg(self):
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'TX', '2412',
        '18', 'LE']
    valid_results = [
        '@result', 'delta_f2_f1_avg_ratio']
    valid_result_value = [
        '', '(16,20)']

    self._WriteCSVContent([
        self.valid_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(2, len(self.test_plan))
    self.assertEquals(set(['F0', 'AA']),
                      set(test.args['bit_pattern'] for test in self.test_plan))

  def testValidRxLE(self):
    rx_args = ['rx_num_packets']
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'RX', '2412',
        '18', 'LE', '10000']
    valid_results = [
        '@result', 'rx_per']
    valid_result_value = [
        '', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + rx_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))

  def testValidRxBDR(self):
    rx_args = ['rx_num_bits']
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'RX', '2412',
        '18', '1DH1', '10000']
    valid_results = [
        '@result', 'rx_ber']
    valid_result_value = [
        '', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + rx_args + valid_results,
        valid_args_value + valid_result_value])

    self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(1, len(self.test_plan))

  def testInvalidRxLE(self):
    rx_args = ['rx_num_bits']
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'RX', '2412',
        '18', 'LE', '10000']
    valid_results = [
        '@result', 'rx_ber']
    valid_result_value = [
        '', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + rx_args + valid_results,
        valid_args_value + valid_result_value])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))

  def testInvalidRxBDR(self):
    rx_args = ['rx_num_packets']
    valid_args_value = [
        '', 'BT', 'BLUETOOTH', 'RX', '2412',
        '18', '1DH1', '10000']
    valid_results = [
        '@result', 'rx_per']
    valid_result_value = [
        '', '(0,20)']

    self._WriteCSVContent([
        self.valid_args + rx_args + valid_results,
        valid_args_value + valid_result_value])

    with self.assertRaises(ValueError):
      self.test_plan.ParseCSVFile(self.temp_path)
    self.assertEquals(0, len(self.test_plan))