"""
单位转换测试
"""

import unittest
import math


YARD_TO_METER = 0.9144


def convert_meter_to_yard(meters):
    return meters / YARD_TO_METER


def convert_yard_to_meter(yards):
    return yards * YARD_TO_METER


def convert_meter_to_kg(meters, width_cm, gsm):
    return meters * (width_cm / 100) * (gsm / 1000)


def convert_yard_to_kg(yards, width_cm, gsm):
    meters = yards * YARD_TO_METER
    return meters * (width_cm / 100) * (gsm / 1000)


def convert_kg_to_meter(kg, width_cm, gsm):
    return kg / ((width_cm / 100) * (gsm / 1000))


def convert_kg_to_yard(kg, width_cm, gsm):
    meters = kg / ((width_cm / 100) * (gsm / 1000))
    return meters / YARD_TO_METER


class TestMeterYardConversion(unittest.TestCase):
    
    def test_meter_to_yard(self):
        result = convert_meter_to_yard(1)
        self.assertAlmostEqual(result, 1.0936, places=4)
    
    def test_yard_to_meter(self):
        result = convert_yard_to_meter(1)
        self.assertAlmostEqual(result, 0.9144, places=4)
    
    def test_meter_yard_roundtrip(self):
        original = 10.5
        yards = convert_meter_to_yard(original)
        back = convert_yard_to_meter(yards)
        self.assertAlmostEqual(original, back, places=6)
    
    def test_yard_meter_roundtrip(self):
        original = 15.3
        meters = convert_yard_to_meter(original)
        back = convert_meter_to_yard(meters)
        self.assertAlmostEqual(original, back, places=6)


class TestLengthToWeightConversion(unittest.TestCase):
    
    def setUp(self):
        self.width_cm = 150
        self.gsm = 200
    
    def test_meter_to_kg(self):
        result = convert_meter_to_kg(10, self.width_cm, self.gsm)
        expected = 10 * 1.5 * 0.2
        self.assertAlmostEqual(result, expected, places=6)
    
    def test_yard_to_kg(self):
        result = convert_yard_to_kg(10, self.width_cm, self.gsm)
        meters = 10 * YARD_TO_METER
        expected = meters * 1.5 * 0.2
        self.assertAlmostEqual(result, expected, places=6)
    
    def test_kg_to_meter(self):
        result = convert_kg_to_meter(3, self.width_cm, self.gsm)
        expected = 3 / (1.5 * 0.2)
        self.assertAlmostEqual(result, expected, places=6)
    
    def test_kg_to_yard(self):
        result = convert_kg_to_yard(3, self.width_cm, self.gsm)
        meters = 3 / (1.5 * 0.2)
        expected = meters / YARD_TO_METER
        self.assertAlmostEqual(result, expected, places=6)


class TestRoundtripConversion(unittest.TestCase):
    
    def setUp(self):
        self.width_cm = 140
        self.gsm = 180
    
    def test_meter_kg_roundtrip(self):
        original = 25.5
        kg = convert_meter_to_kg(original, self.width_cm, self.gsm)
        back = convert_kg_to_meter(kg, self.width_cm, self.gsm)
        self.assertAlmostEqual(original, back, places=6)
    
    def test_yard_kg_roundtrip(self):
        original = 30.0
        kg = convert_yard_to_kg(original, self.width_cm, self.gsm)
        back = convert_kg_to_yard(kg, self.width_cm, self.gsm)
        self.assertAlmostEqual(original, back, places=6)


class TestEdgeCases(unittest.TestCase):
    
    def test_zero_value(self):
        self.assertEqual(convert_meter_to_yard(0), 0)
        self.assertEqual(convert_yard_to_meter(0), 0)
        self.assertEqual(convert_meter_to_kg(0, 150, 200), 0)
    
    def test_large_value(self):
        result = convert_meter_to_yard(10000)
        self.assertAlmostEqual(result, 10000 / YARD_TO_METER, places=2)
    
    def test_small_value(self):
        result = convert_meter_to_yard(0.001)
        self.assertAlmostEqual(result, 0.001 / YARD_TO_METER, places=8)


class TestPriceConversion(unittest.TestCase):
    
    def test_price_per_meter_to_yard(self):
        price_per_meter = 10.0
        price_per_yard = price_per_meter * YARD_TO_METER
        self.assertAlmostEqual(price_per_yard, 9.144, places=3)
    
    def test_price_per_kg_to_meter(self):
        price_per_kg = 50.0
        width_cm = 150
        gsm = 200
        kg_per_meter = (width_cm / 100) * (gsm / 1000)
        price_per_meter = price_per_kg * kg_per_meter
        self.assertAlmostEqual(price_per_meter, 15.0, places=6)


if __name__ == '__main__':
    unittest.main()