import Tests.Fixtures, SummaryFile1, GPS, unittest


class BlockTest(unittest.TestCase):

    def testAverageDensityIsFloat(self):
        """
        We want to make sure no float->integer truncation
        is taking place.
        """

        # Fill a GeoRecord with dummy values so that we
        # can calculate its average population density.
        gr = SummaryFile1.GeoRecord()
        gr.state = '24'
        gr.county = '001'
        gr.tract = '123456'
        gr.block = '1728'
        gr.pop100 = '100'
        gr.arealand = '40'
        gr.areawatr = '40'
        gr.intptlat = '0'
        gr.intptlon = '0'

        b = SummaryFile1.Block(gr)

        # Should be 100/(40 + 40), which is 1.25 when
        # intepreted as a float.
        self.assertEqual(b.population_density(), 1.25)

        
class GeoRecordParserTest(unittest.TestCase):

    def setUp(self):
        self.grp = SummaryFile1.GeoRecordParser()

        
    def testAllOfSubsetParsed(self):
        fixture_path = Tests.Fixtures.Path() + '/SummaryFile1/one_hundred_records.txt'
        records = self.grp.parse_file(fixture_path)
        self.assertEqual(len(records), 100)


    def testSubsetOfBlocksParsed(self):
        fixture_path = Tests.Fixtures.Path() + '/SummaryFile1/one_hundred_records.txt'
        blocks = self.grp.parse_blocks(fixture_path)
        self.assertEqual(len(blocks), 62)


    def testErrorParsingShortLines(self):
        self.assertRaises(SummaryFile1.RecordError, self.grp.parse_line, "This is a short line.")


    def testMdGeoRecordCount(self):
        fixture_path = Tests.Fixtures.Path() + '/SummaryFile1/mdgeo.uf1'
        records = self.grp.parse_file(fixture_path)
        self.assertEqual(len(records), 98763)


    def testMdGeoBlockCount(self):
         fixture_path = Tests.Fixtures.Path() + '/SummaryFile1/mdgeo.uf1'
         blocks = self.grp.parse_blocks(fixture_path)
         self.assertEqual(len(blocks), 79128)


class SummaryFile1Test(unittest.TestCase):

    def testEachBlockIsClosestToItself(self):
        blocks_path = Tests.Fixtures.Path() + '/SummaryFile1/mdgeo.uf1'
        grp = SummaryFile1.GeoRecordParser()
        blocks = grp.parse_blocks(blocks_path)

        # Only test 100 of these guys (or however many blocks there
        # are in those 100 records.
        fixtures_path = Tests.Fixtures.Path() + '/SummaryFile1/one_hundred_records.txt'
        fixtures = grp.parse_blocks(fixtures_path)
        
        for b in fixtures:
            # It's probably unnecessary to copy the coordinates
            # into a new instance here, but whatever.
            b_coords = GPS.Coordinates()
            b_coords.latitude = b.coordinates.latitude
            b_coords.longitude = b.coordinates.longitude
            
            closest_block = SummaryFile1.FindClosestBlock(blocks, b_coords)
            self.assertEqual(b.block, closest_block.block)


    def testEachBlockHasItsOwnAverageDensity(self):
        geo_file_path = Tests.Fixtures.Path() + '/SummaryFile1/mdgeo.uf1'

        # Only test 5 of these guys; they take longer.
        grp = SummaryFile1.GeoRecordParser()
        fixtures_path = Tests.Fixtures.Path() + '/SummaryFile1/five_blocks.txt'
        fixtures = grp.parse_blocks(fixtures_path)
        
        for b in fixtures:
            # It's probably unnecessary to copy the coordinates
            # into a new instance here, but whatever.
            avg_density = SummaryFile1.FindAveragePopulationDensity(b.coordinates, geo_file_path)
            self.assertEqual(b.population_density(), avg_density)
            
    
def suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(GeoRecordParserTest))
    suite.addTest(unittest.makeSuite(SummaryFile1Test))
    suite.addTest(unittest.makeSuite(BlockTest))
    return suite