def test_verify_variables_cidr(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = 0
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = '152.2.136.0'
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = '152.2.136.0/'
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = '152.2.136.0//'
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = '152.2.136.0/Test'
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = '152.2.136.0/26/'
     self.assertFalse(test_subnet.verify_cidr_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.cidr_address = '152.2.136.0/26'
     self.assertTrue(test_subnet.verify_cidr_address())
     self.assertTrue(test_subnet.verify_variables())
 def test_verify_variables_ip_range(self):
     test_subnet = Subnet()
     test_subnet.ip_range = 0
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = '152.2.136.0/26'
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = '152.2.136.63'
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = '152.2.136.0-'
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = '152.2.136.0-152.2.136.0'
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = '152.2.136.62-152.2.136.1'
     self.assertFalse(test_subnet.verify_ip_range())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     self.assertTrue(test_subnet.verify_ip_range())
     self.assertTrue(test_subnet.verify_variables())
예제 #3
0
    def __init__(self):
        self.subnet = Subnet()

        self.total = Tk()
        self.total.wm_title('Total Host Count Calculator')

        self.count_from_cidr = LabelFrame(
            self.total, text='Total Host Count: CIDR Address')
        self.cidr_label = Label(self.count_from_cidr,
                                text='CIDR Address:',
                                width=20)
        self.cidr_entry = Entry(self.count_from_cidr, width=25)

        self.count_from_netmask = LabelFrame(self.total,
                                             text='Total Host Count: Netmask')
        self.netmask_label = Label(self.count_from_netmask,
                                   text='Netmask:',
                                   width=20)
        self.netmask_entry = Entry(self.count_from_netmask, width=25)

        self.count_from_ip_range = LabelFrame(
            self.total, text='Total Host Count: Assignable IP Range')
        self.ip_range_label = Label(self.count_from_ip_range,
                                    text='Assignable IP Range:',
                                    width=20)
        self.ip_range_entry = Entry(self.count_from_ip_range, width=25)

        self.learning_steps = LabelFrame(self.total, text='Learning Steps')

        self.calculate = Button(self.count_from_cidr,
                                text='Calculate',
                                command=lambda: self.get_count_from_cidr())
        self.calculate2 = Button(self.count_from_netmask,
                                 text='Calculate',
                                 command=lambda: self.get_count_from_netmask())
        self.calculate3 = Button(
            self.count_from_ip_range,
            text='Calculate',
            command=lambda: self.get_count_from_ip_range())

        self.count_from_cidr.grid(row=0)
        self.count_from_netmask.grid(row=1)
        self.count_from_ip_range.grid(row=2)
        self.learning_steps.grid(row=3, sticky='W')

        self.cidr_label.grid(row=0, column=0, sticky='W')
        self.cidr_entry.grid(row=0, column=1)
        self.calculate.grid(row=0, column=2)

        self.netmask_label.grid(row=0, column=0, sticky='W')
        self.netmask_entry.grid(row=0, column=1)
        self.calculate2.grid(row=0, column=2)

        self.ip_range_label.grid(row=0, column=0, sticky='W')
        self.ip_range_entry.grid(row=0, column=1)
        self.calculate3.grid(row=0, column=2)

        # self.total.mainloop()
        pass
 def test_general_calculation_ip_range(self):
     test_subnet = Subnet()
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     test_subnet.general_calculation()
     self.assertEqual(test_subnet.cidr_address, '152.2.136.0/26')
     self.assertEqual(test_subnet.netmask, '255.255.255.192')
     self.assertEqual(test_subnet.network_address, '152.2.136.0')
     self.assertEqual(test_subnet.broadcast_address, '152.2.136.63')
     # self.assertEqual(test_subnet.ip_range, '152.2.136.1-152.2.136.62')
     self.assertEqual(test_subnet.total_host_count, 64)
     self.assertEqual(test_subnet.assignable_host_count, 62)
 def test_verify_variables_assignable_host_count(self):
     test_subnet = Subnet()
     test_subnet.assignable_host_count = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_assignable_host_count())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.assignable_host_count = '123'
     self.assertFalse(test_subnet.verify_assignable_host_count())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.assignable_host_count = '62'
     self.assertTrue(test_subnet.verify_assignable_host_count())
     self.assertTrue(test_subnet.verify_variables())
 def test_verify_variables_multiple(self):
     test_subnet = Subnet()
     test_subnet.network_address = 'THIS IS A TEST'
     test_subnet.ip_range = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.network_address = '152.2.136.0'
     test_subnet.ip_range = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.network_address = '152.2.136.0'
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     self.assertTrue(test_subnet.verify_variables())
 def test_verify_variables_total_host_count(self):
     test_subnet = Subnet()
     test_subnet.total_host_count = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_total_host_count())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.total_host_count = '123'
     self.assertFalse(test_subnet.verify_total_host_count())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.total_host_count = '64'
     self.assertTrue(test_subnet.verify_total_host_count())
     self.assertTrue(test_subnet.verify_variables())
 def test_verify_variables_broadcast(self):
     test_subnet = Subnet()
     test_subnet.broadcast_address = 0
     self.assertFalse(test_subnet.verify_broadcast())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.broadcast_address = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_broadcast())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.broadcast_address = '152.2.136.0/26'
     self.assertFalse(test_subnet.verify_broadcast())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.broadcast_address = '152.2.136.63'
     self.assertTrue(test_subnet.verify_broadcast())
     self.assertTrue(test_subnet.verify_variables())
 def test_verify_variables_network_address(self):
     test_subnet = Subnet()
     test_subnet.network_address = 0
     self.assertFalse(test_subnet.verify_network_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.network_address = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_network_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.network_address = '152.2.136.0/26'
     self.assertFalse(test_subnet.verify_network_address())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.network_address = '152.2.136.0'
     self.assertTrue(test_subnet.verify_network_address())
     self.assertTrue(test_subnet.verify_variables())
 def test_verify_variables_netmask(self):
     test_subnet = Subnet()
     test_subnet.netmask = 0
     self.assertFalse(test_subnet.verify_netmask())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.netmask = 'THIS IS A TEST'
     self.assertFalse(test_subnet.verify_netmask())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.netmask = '152.2.136.0'
     self.assertFalse(test_subnet.verify_netmask())
     self.assertFalse(test_subnet.verify_variables())
     test_subnet.netmask = '255.255.255.192'
     self.assertTrue(test_subnet.verify_netmask())
     self.assertTrue(test_subnet.verify_variables())
 def test_reset_variables(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = '152.2.136.0/26'
     test_subnet.network_address = '152.2.136.0'
     test_subnet.netmask = '255.255.255.192'
     test_subnet.broadcast_address = '152.2.136.63'
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     test_subnet.reset_variables()
     self.assertEqual(test_subnet.cidr_address, '')
     self.assertEqual(test_subnet.netmask, '')
     self.assertEqual(test_subnet.network_address, '')
     self.assertEqual(test_subnet.broadcast_address, '')
     self.assertEqual(test_subnet.ip_range, '')
     pass
예제 #12
0
    def __init__(self):
        self.subnet = Subnet()

        self.general_calculator = Tk()
        self.general_calculator.wm_title('General Subnet Calculator')

        self.cidr_label = Label(self.general_calculator, text='CIDR Address:')
        self.network_label = Label(self.general_calculator,
                                   text='Network Address:')
        self.netmask_label = Label(self.general_calculator, text='Netmask:')
        self.broadcast_label = Label(self.general_calculator,
                                     text='Broadcast Address:')
        self.ip_range_label = Label(self.general_calculator,
                                    text='Assignable IP Range:')
        self.total_host_label = Label(self.general_calculator,
                                      text='Total Host Count:')
        self.assignable_host_label = Label(self.general_calculator,
                                           text='Assignable Host Count:')

        self.cidr_entry = Entry(self.general_calculator, width=25)
        self.network_entry = Entry(self.general_calculator, width=25)
        self.netmask_entry = Entry(self.general_calculator, width=25)
        self.broadcast_entry = Entry(self.general_calculator, width=25)
        self.ip_range_entry = Entry(self.general_calculator, width=25)
        self.total_host_entry = Entry(self.general_calculator, width=25)
        self.assignable_host_entry = Entry(self.general_calculator, width=25)

        self.calculate = Button(self.general_calculator,
                                text='Calculate',
                                command=lambda: self.get_entries())

        self.cidr_label.grid(row=0, column=0, sticky='E')
        self.network_label.grid(row=1, column=0, sticky='E')
        self.netmask_label.grid(row=2, column=0, sticky='E')
        self.broadcast_label.grid(row=3, column=0, sticky='E')
        self.ip_range_label.grid(row=4, column=0, sticky='E')
        self.total_host_label.grid(row=5, column=0, sticky='E')
        self.assignable_host_label.grid(row=6, column=0, sticky='E')

        self.cidr_entry.grid(row=0, column=1)
        self.network_entry.grid(row=1, column=1)
        self.netmask_entry.grid(row=2, column=1)
        self.broadcast_entry.grid(row=3, column=1)
        self.ip_range_entry.grid(row=4, column=1)
        self.total_host_entry.grid(row=5, column=1)
        self.assignable_host_entry.grid(row=6, column=1)

        self.calculate.grid(row=7, columnspan=2)
예제 #13
0
    def __init__(self):
        self.subnet = Subnet()

        self.cidr = Tk()
        self.cidr.wm_title('CIDR Calculator')

        self.cidr_from_netmask = LabelFrame(
            self.cidr, text='CIDR: Network Address & Netmask')
        self.net_address_label = Label(self.cidr_from_netmask,
                                       text='Network Address:')
        self.netmask_label = Label(self.cidr_from_netmask, text='Netmask:')
        self.net_address_entry = Entry(self.cidr_from_netmask, width=25)
        self.netmask_entry = Entry(self.cidr_from_netmask, width=25)

        self.cidr_from_ip_range = LabelFrame(
            self.cidr, text='CIDR: Network Address & Assignable IP Range')
        self.net_address_label2 = Label(self.cidr_from_ip_range,
                                        text='Network Address:')
        self.ip_range_label = Label(self.cidr_from_ip_range,
                                    text='Assignable IP Range:')
        self.net_address_entry2 = Entry(self.cidr_from_ip_range, width=25)
        self.ip_range_entry = Entry(self.cidr_from_ip_range, width=25)

        self.learning_steps = LabelFrame(self.cidr, text='Learning Steps')

        self.calculate = Button(self.cidr_from_netmask,
                                text='Calculate',
                                command=lambda: self.get_cidr_from_netmask())
        self.calculate2 = Button(self.cidr_from_ip_range,
                                 text='Calculate',
                                 command=lambda: self.get_cidr_from_ip_range())

        self.cidr_from_netmask.grid(row=0)
        self.cidr_from_ip_range.grid(row=1)
        self.learning_steps.grid(row=2, sticky='W')

        self.net_address_label.grid(row=0, column=0, sticky='W')
        self.net_address_entry.grid(row=1, column=0)
        self.netmask_label.grid(row=0, column=1, sticky='W')
        self.netmask_entry.grid(row=1, column=1)
        self.calculate.grid(row=1, column=2)

        self.net_address_label2.grid(row=0, column=0, sticky='W')
        self.net_address_entry2.grid(row=1, column=0)
        self.ip_range_label.grid(row=0, column=1, sticky='W')
        self.ip_range_entry.grid(row=1, column=1)
        self.calculate2.grid(row=1, column=2)
예제 #14
0
    def __init__(self):
        self.subnet = Subnet()

        self.broadcast = Tk()
        self.broadcast.wm_title('Broadcast Address Calculator')

        self.broadcast_from_cidr = LabelFrame(
            self.broadcast, text='Broadcast Address: CIDR Address')
        self.cidr_label = Label(self.broadcast_from_cidr,
                                text='CIDR Address:',
                                width=20)
        self.cidr_entry = Entry(self.broadcast_from_cidr, width=25)

        self.broadcast_from_ip_range = LabelFrame(
            self.broadcast, text='Broadcast Address: Assignable IP Range')
        self.ip_range_label = Label(self.broadcast_from_ip_range,
                                    text='Assignable IP Range:',
                                    width=20)
        self.ip_range_entry = Entry(self.broadcast_from_ip_range, width=25)

        self.learning_steps = LabelFrame(self.broadcast, text='Learning Steps')

        self.calculate = Button(self.broadcast_from_cidr,
                                text='Calculate',
                                command=lambda: self.get_broadcast_from_cidr())
        self.calculate2 = Button(
            self.broadcast_from_ip_range,
            text='Calculate',
            command=lambda: self.get_broadcast_from_ip_range())

        self.broadcast_from_cidr.grid(row=0)
        self.broadcast_from_ip_range.grid(row=1)
        self.learning_steps.grid(row=2, sticky='W')

        self.cidr_label.grid(row=0, column=0, sticky='W')
        self.cidr_entry.grid(row=0, column=1)
        self.calculate.grid(row=0, column=2)

        self.ip_range_label.grid(row=0, column=0, sticky='W')
        self.ip_range_entry.grid(row=0, column=1)
        self.calculate2.grid(row=0, column=2)
 def test_verify_variables_none(self):
     test_subnet = Subnet()
     self.assertFalse(test_subnet.verify_variable_use())
     self.assertFalse(test_subnet.verify_variables())
 def test_calculate_cidr_from_netmask(self):
     test_subnet = Subnet()
     test_subnet.network_address = '152.2.136.0'
     test_subnet.netmask = '255.255.255.192'
     test_subnet.calculate_cidr_from_netmask()
     self.assertEqual(test_subnet.cidr_address, '152.2.136.0/26')
 def test_calculate_assignable_host_count(self):
     test_subnet = Subnet()
     test_subnet.total_host_count = 64
     test_subnet.calculate_assignable_host_count()
     self.assertEqual(test_subnet.assignable_host_count, 62)
 def test_calculate_total_host_count_from_ip_range(self):
     test_subnet = Subnet()
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     test_subnet.calculate_total_host_count_from_ip_range()
     self.assertEqual(test_subnet.total_host_count, 64)
 def test_calculate_total_host_count_from_netmask(self):
     test_subnet = Subnet()
     test_subnet.netmask = '255.255.255.192'
     test_subnet.calculate_total_host_count_from_netmask()
     self.assertEqual(test_subnet.total_host_count, 64)
 def test_calculate_total_host_count_from_cidr(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = '152.2.136.0/26'
     test_subnet.calculate_total_host_count_from_cidr()
     self.assertEqual(test_subnet.total_host_count, 64)
 def test_calculate_ip_range_from_network_broadcast(self):
     test_subnet = Subnet()
     test_subnet.network_address = '152.2.136.0'
     test_subnet.broadcast_address = '152.2.136.63'
     test_subnet.calculate_ip_range_from_network_broadcast()
     self.assertEqual(test_subnet.ip_range, '152.2.136.1-152.2.136.62')
 def test_calculate_ip_range_from_cidr(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = '152.2.136.0/26'
     test_subnet.calculate_ip_range_from_cidr()
     self.assertEqual(test_subnet.ip_range, '152.2.136.1-152.2.136.62')
 def test_calculate_broadcast_address_from_ip_range(self):
     test_subnet = Subnet()
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     test_subnet.calculate_broadcast_address_from_ip_range()
     self.assertEqual(test_subnet.broadcast_address, '152.2.136.63')
 def test_calculate_broadcast_address_from_cidr(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = '152.2.136.0/26'
     test_subnet.calculate_broadcast_address_from_cidr()
     self.assertEqual(test_subnet.broadcast_address, '152.2.136.63')
 def test_calculate_network_address_from_ip_range(self):
     test_subnet = Subnet()
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     test_subnet.calculate_network_address_from_ip_range()
     self.assertEqual(test_subnet.network_address, '152.2.136.0')
 def test_calculate_network_address_from_cidr(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = '152.2.136.0/26'
     test_subnet.calculate_network_address_from_cidr()
     self.assertEqual(test_subnet.network_address, '152.2.136.0')
 def test_calculate_assignable_host_count_from_netmask(self):
     test_subnet = Subnet()
     test_subnet.netmask = '255.255.255.192'
     test_subnet.calculate_assignable_host_count_from_netmask()
     self.assertEqual(test_subnet.assignable_host_count, 62)
 def test_calculate_netmask_from_ip_range(self):
     test_subnet = Subnet()
     test_subnet.ip_range = '152.2.136.1-152.2.136.62'
     test_subnet.calculate_netmask_from_ip_range()
     self.assertEqual(test_subnet.netmask, '255.255.255.192')
 def test_calculate_netmask_from_cidr(self):
     test_subnet = Subnet()
     test_subnet.cidr_address = '152.2.136.0/26'
     test_subnet.calculate_netmask_from_cidr()
     self.assertEqual(test_subnet.netmask, '255.255.255.192')