Durante o desenvolvimento de um software, tão importante quanto escrever um código organizado e que siga as melhores práticas, é garantir que o mesmo cumpra os requisitos a que ele se propõe. Em outras palavras, garantir que o software funcione de maneira adequada.
O processo de testes de um software faz parte do seu desenvolvimento, porém muitas vezes ele é encarado como algo tedioso e desnecessário. Entretanto, todo bom desenvolvedor sabe que investir tempo escrevendo testes para seu software está longe de ser "desperdício de tempo". O processo de teste, quando feito por uma pessoa, além de sujeitos a falhas é tedioso e demorado. Tendo isso em mente, podemos lançar mão de ferramentas que realizarão o processo de teste por nós. Em Python, umas das ferramentes da bibloteca padrão destinada a teste é a Unittest, que usaremos nesse tutorial.
Nesta série de postagem, irei mostrar o passo-a-passo na criação de testes unitários para um pequeno projeto que vamos criar no github. Vou explicar como configurar a ferramenta Travis, que será responsável por executar os nossos testes no github. A ferramenta Coveralls, que mapeia nosso código, e nos indica o quanto dele está coberto por testes. E como bônus, adicionar ao nosso projeto o Landscape, ferramenta que monitora a "saúde" do nosso código.
Iniciando nosso projeto
Inicialmente, criei no github um repositório que vai receber meu código e que posteriormente será configurado para rodar nossos testes. No meu caso, o repositório foi esse codigo-avulso-test-tutorial. Após realizar o clone, criei a seguite estrutura de diretorios:
.
├── codigo_avulso_test_tutorial
│ └── __init__.py
├── LICENSE
├── README.md
└── test
└── __init__.py
O diretório codigo_avulso_test_tutorial receberá o código da nossa aplicação e o diretório test receberá o código de teste. O nosso projeto consiste de um grupo de classes representando figuras geométricas (quadrados, círculos e etc). Teremos uma classe base chamada FiguraGeometrica que possui dois métodos, a saber: get_area e get_perimetro, sendo ambos metódos abstratos. Cada uma dessas classes filhas de FiguraGeometrica irá possuir sua própria implementação desses métodos.
Dentro do diretório codigo_avulso_test_tutorial, irei criar os fontes do nosso código:
touch figura_geometrica.py circulo.py quadrado.py
Dentro do diretório test, irei criar os fontes do nosso código de teste:
touch figura_geometrica_test.py circulo_test.py quadrado_test.py
Uma observação importante é que os arquivos de teste devem ter o nome terminado em test, para que o módulo de Unittest encontre os nossos arquivos de teste automaticamente. Após a criação dos arquivos, teremos a seguinte estrutura de diretório:
.
├── codigo_avulso_test_tutorial
│ ├── circulo.py
│ ├── figura_geometrica.py
│ ├── __init__.py
│ └── quadrado.py
├── LICENSE
├── README.md
└── test
├── circulo_test.py
├── figura_geometrica_test.py
├── __init__.py
└── quadrado_test.py
Iniciemos agora a implementação do nosso projeto. Mas antes vamos dar uma olhada em alguns conceitos.
Test Driven Development (TDD)
Neste momento, leitor, você deve estar se perguntando: "Não deveríamos escrever primeiro o nosso código e depois escrever os testes?".
Não necessariamente. O processo de escrever os testes antes do código é chamado de TDD - Test Driven Development. Segundo a wikipedia:
"Test Driven Development (TDD) ou em português Desenvolvimento guiado por testes é uma técnica de desenvolvimento de software que baseia em um ciclo curto de repetições: Primeiramente o desenvolvedor escreve um caso de teste automatizado que define uma melhoria desejada ou uma nova funcionalidade. Então, é produzido código que possa ser validado pelo teste para posteriormente o código ser refatorado para um código sob padrões aceitáveis. Kent Beck, considerado o criador ou o 'descobridor' da técnica, declarou em 2003 que TDD encoraja designs de código simples e inspira confiança[1] . Desenvolvimento dirigido por testes é relacionado a conceitos de programação de Extreme Programming, iniciado em 1999,[2] mas recentemente tem-se criado maior interesse pela mesma em função de seus próprios ideais.[3] Através de TDD, programadores podem aplicar o conceito de melhorar e depurar código legado desenvolvido a partir de técnicas antigas.[4]"
Criando o setup.py
Antes de começar a implementar o códigos de teste, vamos criar o arquivo setup.py. Esse arquivo contém informações sobr e o nosso módulo python e facilita em muito a utilização dos testes. Então, vamos criar o arquivo setup.py na pasta raiz do nosso projeto.
touch setup.py
A estrutura do nosso projeto agora está assim:
.
├── codigo_avulso_test_tutorial
│ ├── circulo.py
│ ├── figura_geometrica.py
│ ├── __init__.py
│ └── quadrado.py
├── LICENSE
├── README.md
├── setup.py
└── test
├── circulo_test.py
├── figura_geometrica_test.py
├── __init__.py
└── quadrado_test.py
Abra o setup.py em um editor e adicione as informações conforme exemplo abaixo:
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='codigo-avulso-test-tutorial',
packages=['codigo_avulso_test_tutorial', 'test'],
test_suite='test',
)
No código acima, name representa o nome do seu projeto, packages são os diretórios do seu projeto que possuem código fonte e test_suite indica o diretório onde estão os fontes de teste. É importante declarar esse diretório pois o Unittest irá procurar dentro dele os arquivos de teste que iremos escrever.
Criando testes para a classe FiguraGeometrica
Agora, vamos usar a lógica do TDD. Primeiro criamos o código de teste de uma classe para em seguida criamos o código da mesma. Das classes que criamos, o arquivo figura_geometrica.py servirá como uma classe base para as outras classes. Então vamos começar por elá.
Abra o arquivo figura_geometrica_test.py e seu editor preferido e adicione o código abaixo:
# -*- coding: utf-8 -*-
from unittest import TestCase
from codigo_avulso_test_tutorial.figura_geometrica import FiguraGeometrica
# O nome da classe deve iniciar com a palavra Test
class TestFiguraGeometrico(TestCase):
# Serve para incializar variavei que usaremos
# globalmente nos testes
def setUp(self):
TestCase.setUp(self)
self.fig = FiguraGeometrica()
# Retorna uma NotImplementedError
# O nome do metodo deve comecar com test
def test_get_area(self):
self.assertRaises(NotImplementedError, self.fig.get_area)
# Retorna uma NotImplementedError
# O nome do metodo deve comecar com test
def test_get_perimetro(self):
self.assertRaises(NotImplementedError, self.fig.get_perimetro)
Como podemos observar no código acima, a seguinte linha:
def test_get_area(self):
self.assertRaise(self.fig.test_get_area(), NotImplementedError)
Realiza o seguinte teste. Com o objeto self.fig criado no método setUp(), tentamos chamar o método test_get_perimetro da classe FiguraGeometrica, porém ele verifica se ocorreu a exceção NotImplementedError. Isso é feito porque a classe FiguraGeometrica é uma classe abstrata e possui ambos os métodos get_area e get_perimetro vazios. Isso irá ficar mais claro quando adicionarmos o código da classe FiguraGeometrica. Então, abra o arquivo figura_geometrica.py em seu editor e vamos adicionar o seguinte código:
# -*- coding: utf-8 -*-
class FiguraGeometrica(object):
# Retorna a area da figura
def get_area(self):
raise NotImplementedError
# Retorna o perimetro da figura
def get_perimetro(self):
raise NotImplementedError
A class acima é bem simples. Ela possui um método que retorna a área e outro que retorna o perímetro da figura. Ambos são métodos abstratos, ou seja, devem ser implementados nas classes filhas da classe FiguraGeometrica. Se criarmos um objeto dessa classe e chamarmos um dos dois métodos, uma exceção do tipo NotImplementedError será lançada, pois ambos os métodos possuem escopo vazio.
Finalmente podemos executar o teste da nossa classe. Usando o terminal, no diretorio em que o arquivo setup.py está, execute o seguinte comando:
python setup.py test
Esse nosso comando vai executar a nossa classe TestFiguraGeometrica. Se tudo estiver correto, teremos a seguinte saída:
running test
running egg_info
writing codigo_avulso_test_tutorial.egg-info/PKG-INFO
writing top-level names to codigo_avulso_test_tutorial.egg-info/top_level.txt
writing dependency_links to codigo_avulso_test_tutorial.egg-info/dependency_links.txt
reading manifest file 'codigo_avulso_test_tutorial.egg-info/SOURCES.txt'
writing manifest file 'codigo_avulso_test_tutorial.egg-info/SOURCES.txt'
running build_ext
test_get_area (test.figura_geometrica_test.TestFiguraGeometrico) ... ok
test_get_perimetro (test.figura_geometrica_test.TestFiguraGeometrico) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Caso apareça uma resposta diferente, dê uma olhada na própria saída do teste. Ele indica onde está o erro. Provavelmente, pode ter sido algum erro de digitação, pois os exemplos deste tutorial foram todos testados.
Criando testes para a classe Quadrado
Vamos criar agora outras classes que realmente fazem algo de útil e seus respectivos testes. Começando pela classe Quadrado, vamos escrever um teste para a mesma no arquivo quadrado_test.py.
# -*- coding: utf-8 -*-
from unittest import TestCase
from codigo_avulso_test_tutorial.quadrado import Quadrado
class TestQuadrado(TestCase):
def setUp(self):
TestCase.setUp(self)
self.fig = Quadrado()
def test_get_area(self):
# Verificamos se o resultado é o esperado
# de acordo com a formula de area do quadrado
self.fig.lado = 2
self.assertEqual(self.fig.get_area(), 4)
self.fig.lado = 7.0
self.assertEqual(self.fig.get_area(), 49.0)
def test_get_perimetro(self):
self.fig.lado = 2
self.assertEqual(self.fig.get_perimetro(), 8)
self.fig.lado = 7.0
self.assertEqual(self.fig.get_perimetro(), 28.0)
Em seguida, adicionamos o código da classe Quadrado no arquivo quadrado.py:
# -*- coding: utf-8 -*-
from figura_geometrica import FiguraGeometrica
class Quadrado(FiguraGeometrica):
def __init__(self):
self.lado = 0
# Retorna a area do quadrado
def get_area(self):
return self.lado**2
# Retorna o perimetro do quadrado
def get_perimetro(self):
return 4 * self.lado
Assim como fizemos no exemplo anterior, executamos os testes:
python setup.py test
Se tudo estiver certo, teremos a seguinte saída.
running test
running egg_info
writing codigo_avulso_test_tutorial.egg-info/PKG-INFO
writing top-level names to codigo_avulso_test_tutorial.egg-info/top_level.txt
writing dependency_links to codigo_avulso_test_tutorial.egg-info/dependency_links.txt
reading manifest file 'codigo_avulso_test_tutorial.egg-info/SOURCES.txt'
writing manifest file 'codigo_avulso_test_tutorial.egg-info/SOURCES.txt'
running build_ext
test_get_area (test.quadrado_test.TestQuadrado) ... ok
test_get_perimetro (test.quadrado_test.TestQuadrado) ... ok
test_get_area (test.figura_geometrica_test.TestFiguraGeometrico) ... ok
test_get_perimetro (test.figura_geometrica_test.TestFiguraGeometrico) ... ok
----------------------------------------------------------------------
Ran 4 tests in 0.000s
OK
Uma detalhe interessante a ser observado é que agora os testes da classe Quadrado estão sendo executados junto com os testes da classe FiguraGeometrica sem que fosse necessário alterar nenhuma configuração do projeto, ou adicionar algum novo diretório no arquivo setup.py. Isso acontece por que usamos a sufixo _test no nome dos nossos código fonte de teste e também adicionamos o diretório test na tag test_suite no arquivo setup.py. Desse modo, quando executamos os testes, o módulo python Unittest percorre o diretório test, carrega automaticamente todos os arquivos com sufixo _test e executa os testes dentro deles. Bacana não é?
Criando testes para a classe Circulo
Para encerrarmos o tutorial, vamos agora implementar os testes da classe Círculo.
# -*- coding: utf-8 -*-
import math
from unittest import TestCase
from codigo_avulso_test_tutorial.circulo import Circulo
class TestCirculo(TestCase):
def setUp(self):
TestCase.setUp(self)
self.fig = Circulo()
def test_get_area(self):
# Utilizamos a formula diretamente por conveniencia
# já que math.pi e double e sendo assim, possui
# muitas casas decimais
self.fig.raio = 2
area = math.pi * self.fig.raio**2
self.assertEqual(self.fig.get_area(), area)
self.fig.raio = 7.0
area = math.pi * self.fig.raio**2
self.assertEqual(self.fig.get_area(), area)
def test_get_perimetro(self):
self.fig.raio = 2
perimetro = 2 * math.pi * self.fig.raio
self.assertEqual(self.fig.get_perimetro(), perimetro)
self.fig.raio = 7.0
perimetro = 2 * math.pi * self.fig.raio
self.assertEqual(self.fig.get_perimetro(), perimetro)
E agora a classe Circulo:
# -*- coding: utf-8 -*-
import math
from figura_geometrica import FiguraGeometrica
class Circulo(FiguraGeometrica):
def __init__(self):
self.raio = 0
# Retorna a area do circulo
def get_area(self):
return math.pi * self.raio**2
# Retorna o perimetro do circulo
def get_perimetro(self):
return 2 * math.pi * self.raio
Finalmente, rodamos os testes agora com a presença da classe circúlo:
python setup.py test
Se tudo estiver certo, teremos a seguinte saída.
running test
running egg_info
writing codigo_avulso_test_tutorial.egg-info/PKG-INFO
writing top-level names to codigo_avulso_test_tutorial.egg-info/top_level.txt
writing dependency_links to codigo_avulso_test_tutorial.egg-info/dependency_links.txt
reading manifest file 'codigo_avulso_test_tutorial.egg-info/SOURCES.txt'
writing manifest file 'codigo_avulso_test_tutorial.egg-info/SOURCES.txt'
running build_ext
test_get_area (test.quadrado_test.TestQuadrado) ... ok
test_get_perimetro (test.quadrado_test.TestQuadrado) ... ok
test_get_area (test.figura_geometrica_test.TestFiguraGeometrico) ... ok
test_get_perimetro (test.figura_geometrica_test.TestFiguraGeometrico) ... ok
test_get_area (test.circulo_test.TestCirculo) ... ok
test_get_perimetro (test.circulo_test.TestCirculo) ... ok
----------------------------------------------------------------------
Ran 6 tests in 0.001s
OK
Conclusão
Com os testes ok, só nos resta subir o código para o github:
git add --all
git commit -m "[NEW] Adicionado classes e testes"
git push origin master
Esse tutorial ficou bem extenso, mas espero que tenha sido útil pra vocês. No próxima parte do tutorial, vamos ver como configurar o Travis, para que ele execute nossos testes quando realizarmos um push ou um pull request para o github. Também veremos o Coveralls que emite relatórios do quando do seu código está coberto por testes, algo muito interessante para ver se um software é bem testado.
Os testes que escrevemos foram bem simples, apenas para fim de exemplo. Porém em uma aplicação séria, deve-se ter cuidado na hora de escrever os testes, de maneira a garantir que todas as possibilidades de erros sejam cobertas. A filosofia do TDD de escrever os testes antes do código da nossa aplicação, é algo que exige prática. Eu mesmo ainda não me sinto completamente a vontade seguindo esse fluxo de trabalho. Mas, escrever os testes primeiro te ajuda a manter seu código coerente e funcional, pois vocẽ vai precisar fazê-lo passar pelos testes.
É isso pessoal. Obrigado por ler até aqui. Até a próxima postagem!
Publicado originalmente: python-com-unittest-travis-ci-coveralls-e-landscape-parte-1-de-4
Para ser capaz de se comunicar em uma rede , cada computador deve ter uma direção IP exclusivo. Nas classes de endereços IP, três classes de endereço são utilizados para atribuir endereços IP aos computadores. O tamanho eo tipo da rede irá determinar a classe de endereço IP que se aplicam quando nós fornecer endereços IP a computadores e outros hosts na nossa rede.
O endereço IP é o identificador exclusivo que diferencia um do outro computador em uma rede e ajuda a localizar onde esse computador reside. Um endereço IP para cada componente do computador e da rede é necessária, como um roteador , que se comunica via TCP / IP.
O endereço IP identifica a localização de um computador na rede, como o número do endereço identifica uma casa em uma cidade. Como é o caso com o endereço específico de uma casa, que é único, mas segue certas convenções, um endereço de IP deve ser único, mas de acordo com um formato padrão. Um endereço de IP é formado por um conjunto de quatro números, cada um dos quais pode variar de 0 a 255.
Componentes de um endereço IP
Como o endereço de uma casa tem duas partes (uma rua e um código de cartão), um endereço de IP também é composto de duas partes: a identificação de host e ID da rede. ID de Rede A primeira parte de um endereço IP é a identificação de rede, que identifica o segmento de rede onde o computador está localizado.
Todos os computadores em um mesmo segmento deve ter o mesmo ID de rede, como casas em uma determinada área têm o mesmo código postal. HOSTID A segunda parte de um endereço IP é a identificação de host, que identifica um computador, um router ou outro dispositivo de um segmento.
O ID de cada host deve ser exclusivo para o ID de rede, como o endereço de uma casa que é único dentro do código postal.
É importante notar que como duas áreas de código postal diferentes podem ter o mesmo endereço, duas equipes com diferentes IDs de rede pode ter o mesmo ID de acolhimento. No entanto, a combinação de ID de rede e a identificação de host deve ser único para todos os computadores que se comunicam uns com os outros.
classes de endereços são usados para atribuir IDs de rede para as organizações para as equipes de suas redes para se comunicar on a Internet . classes de endereços são também usados para definir o ponto de divisão entre o ID de rede e a identificação de host.
Ele é atribuído a uma organização um bloco de endereços IP, que são referenciados para os endereços de rede ID e dependendo de o tamanho da organização. Por exemplo, você atribuir um ID de rede Classe C para uma organização com 200 anfitriões, ID de rede e uma classe B para uma organização com 20.000 hosts.
classe A
Endereços classe A são atribuídos a redes com um grande número de hosts. Esta classe permite redes 126, usando o primeiro número de identificação para a rede. Os restantes três números são utilizados para a identificação de host, permitindo 16.777.214 hosts por rede.
classe B
Os endereços de classe B são atribuídos a redes de médio a grande. Esta classe permite 16.384 redes, usando os dois primeiros números da ID de rede. Os dois números restantes são usados para a identificação de host, permitindo que 65.534 hosts por rede.
classe C
Os endereços de classe C são usados para pequenas redes locais (LANs). Esta classe permite que cerca de 2.097.152 redes usando os três primeiros números da ID de rede. O número restante é utilizado para a identificação de host, permitindo que 254 hosts por rede.
Classes D e E
As classes D e E não são atribuídos a hosts. Os endereços de classe D são utilizados para multicast e endereços de classe E são reservados para uso futuro.
Determinar a classe de endereço
Os endereços IP aulas é baseado na estrutura do endereço IP e fornece uma maneira sistemática para diferenciar rede IDs de acolhimento IDs. Não são quatro segmentos numéricos de um endereço IP. Um endereço de IP pode ser representada como WXYZ , onde W , X , e e z números com valores que variam de 0 a 255. Dependendo sobre o valor do primeiro número, W na representação numérica, endereços IP são classificados em cinco classes de endereços como mostrado na tabela seguinte:
Determinar o ID de rede e de acolhimento
endereços IP na classe A, a identificação de rede é o primeiro número do endereço IP. Na classe de rede B ID são os dois primeiros números; e classe C, a ID da rede são os três primeiros números do endereço IP. Os números restantes identificar o ID host.
A identificação de rede tem uma estrutura de quatro números como o endereço IP. Portanto, se o primeiro número, W , um endereço de IP representa a identificação da rede, da estrutura da ID de rede é W .0.0.0, com 0 sendo os restantes três números. A estrutura da identificação de host é xyz . Note-se que o anfitrião é não precedida por 0.
Por exemplo, o endereço IP 172.16.53.46 seria um endereço de classe B como w = 172 e está entre 128 e 191. A identificação de rede seria 172.16.0.0 e a identificação de host 53,46 (nenhum período em o fim).
Subdivisão de uma REDE
Podemos estender uma rede utilizando dispositivos físicos, como roteadores e pontes, para adicionar segmentos de rede. Também podem usar dispositivos físicos para dividir uma rede em segmentos menores para aumentar a eficiência da rede.
segmentos de rede separados por roteadores são chamados sub-redes . Quando você criar sub-redes, devemos dividir o ID de rede para os anfitriões nas sub-redes. Dividindo o ID de rede usado para se comunicar IDs de rede internet menores (em função do número de endereços IP identificados) para uma sub-rede é chamado de subdivisão de uma rede.
Para identificar as novas identificações de rede cada sub-rede, devemos usar uma máscara de sub-rede para especificar qual parte do endereço IP será usado pela nova ID de rede da sub-rede. Podemos localizar um host em uma rede analisada a sua ID de rede.
IDs de rede correspondente mostrar quais hosts estão na mesma sub-rede. Se as identificações de rede não são os mesmos, sabemos que estão em sub-redes diferentes e vai precisar de um roteador para estabelecer a comunicação entre eles.
sub-redes
Como um número cada vez maior de equipamentos e de volume de tráfego em uma rede Ethernet , o crescimento ocorre colisão de dados e desempenho da rede é reduzida. Para resolver este problema, um equipamento de rede Ethernet são agrupados em divisões físicas, chamados segmentos, separados por um dispositivo físico, como um roteador ou ponte.
Em um ambiente TCP / IP, separados por roteadores segmentos chamados sub-redes. Todos os computadores que pertencem a uma sub-rede têm o mesmo ID de rede em seus endereços IP. Cada sub-rede deve ter um ID de rede diferente para se comunicar com outras sub-redes. Com base na identificação de rede, sub-redes definir divisões lógicas de uma rede. As equipes que estão em diferentes sub-redes precisam se comunicar através de roteadores.
máscaras de subrede
No método de abordar em sala de aula, o número de redes e hosts disponíveis para uma classe de endereço específico é predeterminado. Consequentemente, uma organização que tem atribuído um ID de rede tem uma rede identificação única fixo e um número de hosts específicos determinados pela classe endereço para o qual o endereço IP pertence.
Com o exclusivo ID de rede, a organização só pode ter uma rede de conexão com o seu número de host atribuído. Se o número de hosts é grande, a única rede não pode funcionar de forma eficaz. Para resolver este problema, introduziu o conceito de sub-redes.
Sub-redes permitem que um único ID de rede de uma turma é dividida em IDs de rede menores (definido pelo número de endereços IP identificados). Usando esses vários IDs de rede menores, a rede pode ser dividido em sub-redes, cada uma com um ID de rede diferente, também chamado de sub-rede ID.
máscaras de sub-estrutura
Para dividir um ID de rede, usamos uma máscara de sub-rede. Uma máscara de sub-rede é uma tela que diferencia uma rede ID identificação de host em um endereço IP, mas não se restringe pelas mesmas regras que o método de aulas anteriores. Uma máscara de sub-rede está formada por um conjunto de quatro números, semelhante a um endereço de IP.
O valor destes números entre 0 e 255.
No método de classes, cada um dos quatro números só podem assumir o valor máximo 255 ou o valor mínimo 0. Os quatro números são organizados como valores máximos adjacentes seguidos de valores mínimos adjacentes. Os valores máximo representa o ID de rede e valores mínimos representam a identificação do host. Por exemplo, 255.255.0.0 é uma máscara de sub-rede válida, mas 255.0.255.0 não é. A máscara de sub-rede 255.255.0.0 identifica o ID de rede como os dois primeiros números do endereço IP.
máscaras de sub-padrão
No método de classes, cada classe de endereço tem uma máscara de sub-rede padrão. A tabela a seguir lista as máscaras de sub-padrão para cada classe de endereço.
Máscaras de sub-rede personalizada
Quando dividir um ID de rede existente para criar sub-redes adicionais, podemos usar qualquer uma das máscaras de sub anteriores com qualquer endereço IP ou ID de rede. Assim, o endereço IP 172.16.2.200 poderia ser 255.255.255.0 máscara de sub-rede e ID de rede 172.16.2.0 ou sub-rede padrão máscara 255.255.0.0 com o ID de rede 172.16.0.0. Isso permite que uma organização sub-redes de uma rede ID 172.16.0.0 classe B em IDs de rede menores existente para coincidir com a configuração atual da rede.
DETERMINAÇÃO DO HOSTS local e remoto
Após a identificação da rede de um hospedeiro tenha sido identificada, é fácil de determinar se outro hospedeiro é local ou remoto a partir dele. Para fazer isso, nós comparamos as identificações de rede de ambos os hosts. Se forem iguais, os dois hosts estão na mesma sub-rede. Se não o fizerem, isso significa que os anfitriões estão em sub-redes diferentes e requer um roteador para transmitir dados entre eles.
exemplo 1
Suponha que as duas equipes A e B com endereços IP 192.168.1.100 e 192.168.2.100 e uma máscara de sub-rede 255.255.0.0. Como mostrado na tabela seguinte, uma identificação de rede corresponder os seus endereços de IP. Portanto, as equipes A e B são locais.
exemplo 2
Outro exemplo seria computadores A e D com endereços IP 192.168.1.100 e 192.168.2.100 e uma máscara de subrede 255.255.255.0. IDs de rede não correspondem estes endereços IP, como mostrado na tabela a seguir. Portanto, a Equipa A equipa é D. remoto
PLANEJAMENTO endereçamento IP
Uma vez estabelecida uma rede, todos os computadores que estão nele precisa de um endereço IP; como a habitação de um edifício, eles precisam de endereços atribuídos a eles. Sem um endereço IP, um computador não recebe os dados para ser direcionado para ele. E como uma casa endereços, o formato do endereço IP deve seguir algumas orientações para garantir que os dados são transmitidos para o computador correto.
Esta seção explica as diretrizes para atribuição de IDs de rede e host.
orientações que abordam
Devemos considerar algumas orientações sobre os números usados para a ID de rede e a identificação de host ao atribuir um endereço IP usando classes. Estas orientações são as seguintes:
O primeiro número da ID da rede não pode ser 127. Este número de ID é reservado para teste de conexão, como fazer um loop local.
Os números de identificação de acolhimento não podem estar todos 255, pois este endereço é usado como endereço de broadcast IP.
O ID de acolhimento não pode ser todos os zeros (0s), pois este endereço é usado para indicar um ID de rede.
A identificação de host deve ser exclusivo para o ID da rede local.
IDs ATRIBUIÇÃO DE REDE
A identificação de rede identifica os hosts TCP / IP localizado na mesma sub-rede física . Todos os hosts na mesma sub-rede deve ser atribuído o mesmo ID de rede para que eles possam se comunicar com o outro.
Todas as sub-redes deve ter um único ID de rede. Por exemplo, a sub-rede A pode ter a identificação da rede 10.0.0.0, sub-rede B poderia ter a identificação de rede 192.168.2.0, eo sub-rede C pode ter o ID de rede 172.16.0.0. A tabela a seguir mostra uma lista de IDs válidos por um intervalos de rede rede.
Nota: Se você planeja para conectar a sua rede para a Internet, você deve garantir que a parte ID de rede do endereço IP é único em comparação com outras redes de Internet. De atribuição de um número de rede IP válido, você pode contactar o fornecedor de serviços na Internet. Você pode dividir a rede em sub-redes usando máscaras sub-rede.
