private Pac pac;


    public KerberosPacAuthData ( byte[] token, Map<Integer, KerberosKey> keys ) throws PACDecodingException {
        this.pac = new Pac(token, keys);
    }


    public Pac getPac () {
        return this.pac;
    }

            Assert.assertEquals(1, ed.getUserAuthorizations().size());

            KerberosPacAuthData pacData = (KerberosPacAuthData) ed.getUserAuthorizations().get(0);
            Pac pac = pacData.getPac();
            PacLogonInfo li = pac.getLogonInfo();
            Assert.assertEquals("test1", li.getUserName());
        } finally {
            Files.deleteIfExists(p);
            Files.deleteIfExists(krbConfig);

        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc methodDesc = beanDesc.getMethodDesc("getAaa");
        assertThat(methodDesc, is(notNullValue()));
        assertThat(methodDesc.getMethodName(), is("getAaa"));
        beanDesc.getMethodDesc("getaaa");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetMethodNoException() throws Exception {

        final PropertyDesc propDesc = beanDesc.getPropertyDesc("cal");
        final Date date = new Date();
        propDesc.setValue(myBean, date);
        assertThat(myBean.getCal().getTime(), is(date));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSetIntegerValueToString() throws Exception {
        final MyBean myBean = new MyBean();

router_b = APIRouter(route_class=APIRouteB)
router_c = APIRouter(route_class=APIRouteC)


@router_a.get("/")
def get_a():
    return {"msg": "A"}


@router_b.get("/")
def get_b():
    return {"msg": "B"}


@router_c.get("/")
def get_c():
    return {"msg": "C"}


router_b.include_router(router=router_c, prefix="/c")
router_a.include_router(router=router_b, prefix="/b")

  public void testKeySetIteratorRemove() {
    int initialSize = getNumElements();
    Iterator<K> iterator = getMap().keySet().iterator();
    iterator.next();
    iterator.remove();
    assertEquals(initialSize - 1, getMap().size());
    assertEquals(initialSize - 1, getMap().inverse().size());
  }

        map.put("c", 3);
        map.put("d", 1.4);
        final HogeDto hoge = new HogeDto();
        BeanUtil.copyMapToBean(map, hoge);
        assertThat(hoge.getA(), is("A"));
        assertThat(hoge.isB(), is(true));
        assertThat(hoge.getC(), is(3));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testCopyBeanToBean() throws Exception {

    assertTrue(getMap().remove(k0(), v0()));
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedPresentKeyWrongValue() {
    assertFalse(getMap().remove(k0(), v3()));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedWrongKeyPresentValue() {
    assertFalse(getMap().remove(k3(), v0()));

  private final Key key;

  private final String toString;
  private final int bits;
  private final boolean supportsClone;

  MacHashFunction(String algorithmName, Key key, String toString) {
    this.prototype = getMac(algorithmName, key);
    this.key = checkNotNull(key);
    this.toString = checkNotNull(toString);
    this.bits = prototype.getMacLength() * Byte.SIZE;
    this.supportsClone = supportsClone(prototype);
  }

    extends AbstractContainerTester<Map<K, V>, Entry<K, V>> {
  protected Map<K, V> getMap() {
    return container;
  }

  @Override
  protected Collection<Entry<K, V>> actualContents() {
    return getMap().entrySet();
  }

  /** @see AbstractContainerTester#resetContainer() */
  protected final void resetMap() {
    resetContainer();
  }