mirror of
https://github.com/google/nomulus.git
synced 2025-04-30 03:57:51 +02:00
Use try-with-resources pattern in RdeParserTest
This fixes a whole mess of Eclipse warnings about a Closeable not calling close(). ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=135407085
This commit is contained in:
mcilwain
Ben McIlwain
parent
64426d3c7c
commit
5a4926323e
1 changed files with 270 additions and 219 deletions
|
|
@ -44,8 +44,7 @@ public class RdeParserTest {
|
|||
|
||||
private InputStream xml;
|
||||
|
||||
@Rule
|
||||
public final ExceptionRule thrown = new ExceptionRule();
|
||||
@Rule public final ExceptionRule thrown = new ExceptionRule();
|
||||
|
||||
private void checkHeader(RdeHeader header) {
|
||||
assertThat(header.getTld()).isEqualTo("test");
|
||||
|
|
@ -70,410 +69,462 @@ public class RdeParserTest {
|
|||
|
||||
@Test
|
||||
public void testGetHeader_returnsHeader() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetContactNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeContact-1.0:contact");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getContact();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeContact-1.0:contact");
|
||||
parser.getContact();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetContactAtElement_returnsContact() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextContact();
|
||||
XjcRdeContact contact = parser.getContact();
|
||||
assertThat(contact.getId()).isEqualTo("sh8013");
|
||||
assertThat(contact.getClID()).isEqualTo("RegistrarX");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextContact();
|
||||
XjcRdeContact contact = parser.getContact();
|
||||
assertThat(contact.getId()).isEqualTo("sh8013");
|
||||
assertThat(contact.getClID()).isEqualTo("RegistrarX");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextContact_advancesParser() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
// there is only one contact in the escrow file
|
||||
assertThat(parser.nextContact()).isTrue();
|
||||
assertThat(parser.isAtContact()).isTrue();
|
||||
assertThat(parser.nextContact()).isFalse();
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
// there is only one contact in the escrow file
|
||||
assertThat(parser.nextContact()).isTrue();
|
||||
assertThat(parser.isAtContact()).isTrue();
|
||||
assertThat(parser.nextContact()).isFalse();
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipZeroContacts_skipsZero() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipContacts(0)).isEqualTo(0);
|
||||
assertThat(parser.nextContact()).isTrue();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipContacts(0)).isEqualTo(0);
|
||||
assertThat(parser.nextContact()).isTrue();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipOneContactFromBeginning_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipContacts(1)).isEqualTo(1);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipContacts(1)).isEqualTo(1);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipOneContactFromFirstContact_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextContact();
|
||||
assertThat(parser.skipContacts(1)).isEqualTo(1);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextContact();
|
||||
assertThat(parser.skipContacts(1)).isEqualTo(1);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkip9999Contacts_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipContacts(9999)).isEqualTo(1);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipContacts(9999)).isEqualTo(1);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipContactsFromEnd_skipsZero() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextContact();
|
||||
parser.nextContact();
|
||||
assertThat(parser.skipContacts(1)).isEqualTo(0);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextContact();
|
||||
parser.nextContact();
|
||||
assertThat(parser.skipContacts(1)).isEqualTo(0);
|
||||
assertThat(parser.isAtContact()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaderAfterNextContact_returnsHeader() throws Exception {
|
||||
// verify that the header is still available after advancing to next contact
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextContact();
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextContact();
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDomainNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeDomain-1.0:domain");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getDomain();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeDomain-1.0:domain");
|
||||
parser.getDomain();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDomainAtElement_returnsDomain() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextDomain();
|
||||
XjcRdeDomain domain = parser.getDomain();
|
||||
assertThat(domain.getName()).isEqualTo("example1.test");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextDomain();
|
||||
XjcRdeDomain domain = parser.getDomain();
|
||||
assertThat(domain.getName()).isEqualTo("example1.test");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextDomain_advancesParser() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
// there are 2 domains in the escrow file
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
assertThat(parser.nextDomain()).isTrue();
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
assertThat(parser.nextDomain()).isTrue();
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
assertThat(parser.nextDomain()).isFalse();
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
// there are 2 domains in the escrow file
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
assertThat(parser.nextDomain()).isTrue();
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
assertThat(parser.nextDomain()).isTrue();
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
assertThat(parser.nextDomain()).isFalse();
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipZeroDomains_skipsZero() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipDomains(0)).isEqualTo(0);
|
||||
assertThat(parser.nextDomain()).isTrue();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipDomains(0)).isEqualTo(0);
|
||||
assertThat(parser.nextDomain()).isTrue();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipOneDomainFromBeginning_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipDomains(1)).isEqualTo(1);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
// prove that the parser advanced to the second domain
|
||||
assertThat(parser.nextDomain()).isFalse();
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipDomains(1)).isEqualTo(1);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
// prove that the parser advanced to the second domain
|
||||
assertThat(parser.nextDomain()).isFalse();
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipTwoDomainsFromBeginning_skipsTwo() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipDomains(2)).isEqualTo(2);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipDomains(2)).isEqualTo(2);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipOneDomainFromFirstDomain_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextDomain();
|
||||
assertThat(parser.skipDomains(1)).isEqualTo(1);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
// prove that the parser advanced to the second domain
|
||||
assertThat(parser.nextDomain()).isFalse();
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextDomain();
|
||||
assertThat(parser.skipDomains(1)).isEqualTo(1);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isTrue();
|
||||
// prove that the parser advanced to the second domain
|
||||
assertThat(parser.nextDomain()).isFalse();
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipTwoDomainsFromFirstDomain_skipsTwo() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextDomain();
|
||||
assertThat(parser.skipDomains(2)).isEqualTo(2);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextDomain();
|
||||
assertThat(parser.skipDomains(2)).isEqualTo(2);
|
||||
// there are two domains
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkip9999Domains_skipsTwo() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipDomains(9999)).isEqualTo(2);
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipDomains(9999)).isEqualTo(2);
|
||||
assertThat(parser.isAtDomain()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipDomainsFromEnd_skipsZero() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextDomain();
|
||||
parser.nextDomain();
|
||||
parser.nextDomain();
|
||||
assertThat(parser.skipDomains(1)).isEqualTo(0);
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextDomain();
|
||||
parser.nextDomain();
|
||||
parser.nextDomain();
|
||||
assertThat(parser.skipDomains(1)).isEqualTo(0);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaderAfterNextDomain_returnsHeader() throws Exception {
|
||||
// verify that the header is still available after advancing to next domain
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextDomain();
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextDomain();
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHostNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeHost-1.0:host");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getHost();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class, "Not at element urn:ietf:params:xml:ns:rdeHost-1.0:host");
|
||||
parser.getHost();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHostAtElement_returnsHost() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextHost();
|
||||
XjcRdeHost host = parser.getHost();
|
||||
assertThat(host.getName()).isEqualTo("ns1.example.com");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextHost();
|
||||
XjcRdeHost host = parser.getHost();
|
||||
assertThat(host.getName()).isEqualTo("ns1.example.com");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextHost_advancesParser() throws Exception {
|
||||
// the header lies, there are 2 hosts in the file
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
assertThat(parser.nextHost()).isTrue();
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
assertThat(parser.nextHost()).isTrue();
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
assertThat(parser.nextHost()).isFalse();
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
assertThat(parser.nextHost()).isTrue();
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
assertThat(parser.nextHost()).isTrue();
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
assertThat(parser.nextHost()).isFalse();
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipZeroHosts_skipsZero() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipHosts(0)).isEqualTo(0);
|
||||
assertThat(parser.nextHost()).isTrue();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipHosts(0)).isEqualTo(0);
|
||||
assertThat(parser.nextHost()).isTrue();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipOneHostFromBeginning_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipHosts(1)).isEqualTo(1);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
// prove that the parser advanced to the second host
|
||||
assertThat(parser.nextHost()).isFalse();
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipHosts(1)).isEqualTo(1);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
// prove that the parser advanced to the second host
|
||||
assertThat(parser.nextHost()).isFalse();
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipTwoHostsFromBeginning_skipsTwo() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipHosts(2)).isEqualTo(2);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipHosts(2)).isEqualTo(2);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipOneHostFromFirstHost_skipsOne() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextHost();
|
||||
assertThat(parser.skipHosts(1)).isEqualTo(1);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
// prove that the parser advanced to the second host
|
||||
assertThat(parser.nextHost()).isFalse();
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextHost();
|
||||
assertThat(parser.skipHosts(1)).isEqualTo(1);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isTrue();
|
||||
// prove that the parser advanced to the second host
|
||||
assertThat(parser.nextHost()).isFalse();
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipTwoHostsFromFirstHost_skipsTwo() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextHost();
|
||||
assertThat(parser.skipHosts(2)).isEqualTo(2);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextHost();
|
||||
assertThat(parser.skipHosts(2)).isEqualTo(2);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkip9999Hosts_skipsTwo() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.skipHosts(9999)).isEqualTo(2);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.skipHosts(9999)).isEqualTo(2);
|
||||
// there are two hosts
|
||||
assertThat(parser.isAtHost()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSkipHostFromEnd_skipsZero() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextHost();
|
||||
parser.nextHost();
|
||||
parser.nextHost();
|
||||
assertThat(parser.skipHosts(1)).isEqualTo(0);
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextHost();
|
||||
parser.nextHost();
|
||||
parser.nextHost();
|
||||
assertThat(parser.skipHosts(1)).isEqualTo(0);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaderAfterNextHost_returnsHeader() throws Exception {
|
||||
// verify that the header is still available after advancing to next host
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextHost();
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextHost();
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRegistrarNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeRegistrar-1.0:registrar");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getRegistrar();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeRegistrar-1.0:registrar");
|
||||
parser.getRegistrar();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRegistrarAtElement_returnsRegistrar() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextRegistrar();
|
||||
XjcRdeRegistrar registrar = parser.getRegistrar();
|
||||
assertThat(registrar.getId()).isEqualTo("RegistrarX");
|
||||
assertThat(registrar.getName()).isEqualTo("Registrar X");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextRegistrar();
|
||||
XjcRdeRegistrar registrar = parser.getRegistrar();
|
||||
assertThat(registrar.getId()).isEqualTo("RegistrarX");
|
||||
assertThat(registrar.getName()).isEqualTo("Registrar X");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextRegistrar_advancesParser() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.isAtRegistrar()).isFalse();
|
||||
assertThat(parser.nextRegistrar()).isTrue();
|
||||
assertThat(parser.isAtRegistrar()).isTrue();
|
||||
assertThat(parser.nextRegistrar()).isFalse();
|
||||
assertThat(parser.isAtRegistrar()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.isAtRegistrar()).isFalse();
|
||||
assertThat(parser.nextRegistrar()).isTrue();
|
||||
assertThat(parser.isAtRegistrar()).isTrue();
|
||||
assertThat(parser.nextRegistrar()).isFalse();
|
||||
assertThat(parser.isAtRegistrar()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaderAfterNextRegistrar_returnsHeader() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextRegistrar();
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextRegistrar();
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetNndnNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeNNDN-1.0:NNDN");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getNndn();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class, "Not at element urn:ietf:params:xml:ns:rdeNNDN-1.0:NNDN");
|
||||
parser.getNndn();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetNndnAtElement_returnsNndn() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextNndn();
|
||||
XjcRdeNndn nndn = parser.getNndn();
|
||||
assertThat(nndn.getAName()).isEqualTo("xn--exampl-gva.test");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextNndn();
|
||||
XjcRdeNndn nndn = parser.getNndn();
|
||||
assertThat(nndn.getAName()).isEqualTo("xn--exampl-gva.test");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextNndn_advancesParser() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.isAtNndn()).isFalse();
|
||||
assertThat(parser.nextNndn()).isTrue();
|
||||
assertThat(parser.isAtNndn()).isTrue();
|
||||
assertThat(parser.nextNndn()).isFalse();
|
||||
assertThat(parser.isAtNndn()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.isAtNndn()).isFalse();
|
||||
assertThat(parser.nextNndn()).isTrue();
|
||||
assertThat(parser.isAtNndn()).isTrue();
|
||||
assertThat(parser.nextNndn()).isFalse();
|
||||
assertThat(parser.isAtNndn()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaderAfterNextNndn_returnsHeader() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextNndn();
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextNndn();
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetIdnNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeIDN-1.0:idnTableRef");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getIdn();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeIDN-1.0:idnTableRef");
|
||||
parser.getIdn();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetIdnAtElement_returnsIdn() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextIdn();
|
||||
XjcRdeIdn idn = parser.getIdn();
|
||||
// url contains whitespace
|
||||
assertThat(idn.getUrl().trim())
|
||||
.isEqualTo("http://www.iana.org/domains/idn-tables/tables/br_pt-br_1.0.html");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextIdn();
|
||||
XjcRdeIdn idn = parser.getIdn();
|
||||
// url contains whitespace
|
||||
assertThat(idn.getUrl().trim())
|
||||
.isEqualTo("http://www.iana.org/domains/idn-tables/tables/br_pt-br_1.0.html");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextIdn_advancesParser() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.isAtIdn()).isFalse();
|
||||
assertThat(parser.nextIdn()).isTrue();
|
||||
assertThat(parser.isAtIdn()).isTrue();
|
||||
assertThat(parser.nextIdn()).isFalse();
|
||||
assertThat(parser.isAtIdn()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.isAtIdn()).isFalse();
|
||||
assertThat(parser.nextIdn()).isTrue();
|
||||
assertThat(parser.isAtIdn()).isTrue();
|
||||
assertThat(parser.nextIdn()).isFalse();
|
||||
assertThat(parser.isAtIdn()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaderAfterNextIdn_returnsHeader() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextIdn();
|
||||
checkHeader(parser.getHeader());
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextIdn();
|
||||
checkHeader(parser.getHeader());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetEppParamsNotAtElement_throwsIllegalStateException() throws Exception {
|
||||
thrown.expect(IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeEppParams-1.0:eppParams");
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.getEppParams();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
thrown.expect(
|
||||
IllegalStateException.class,
|
||||
"Not at element urn:ietf:params:xml:ns:rdeEppParams-1.0:eppParams");
|
||||
parser.getEppParams();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetEppParamsAtElement_returnsEppParams() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
parser.nextEppParams();
|
||||
XjcRdeEppParams eppParams = parser.getEppParams();
|
||||
assertThat(eppParams.getVersions()).containsExactly("1.0");
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
parser.nextEppParams();
|
||||
XjcRdeEppParams eppParams = parser.getEppParams();
|
||||
assertThat(eppParams.getVersions()).containsExactly("1.0");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNextEppParamsAdvancesParser() throws Exception {
|
||||
RdeParser parser = new RdeParser(xml);
|
||||
assertThat(parser.isAtEppParams()).isFalse();
|
||||
assertThat(parser.nextEppParams()).isTrue();
|
||||
assertThat(parser.isAtEppParams()).isTrue();
|
||||
assertThat(parser.nextEppParams()).isFalse();
|
||||
assertThat(parser.isAtEppParams()).isFalse();
|
||||
try (RdeParser parser = new RdeParser(xml)) {
|
||||
assertThat(parser.isAtEppParams()).isFalse();
|
||||
assertThat(parser.nextEppParams()).isTrue();
|
||||
assertThat(parser.isAtEppParams()).isTrue();
|
||||
assertThat(parser.nextEppParams()).isFalse();
|
||||
assertThat(parser.isAtEppParams()).isFalse();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue