public enum ChampData {
    ALL("all"),
    ALLYTIPS("allytips"),
    ALTIMAGES("altimages"),
    BLURB("blurb"),
    ENEMYTIPS("enemytips"),
    IMAGE("image"),
    INFO("info"),
    LORE("lore"),
    PARTYPE("partype"),
    PASSIVE("passive"),
    RECOMMENDED("recommended"),
    SKINS("skins"),
    SPELLS("spells"),
    STATS("stats"),
    TAGS("tags");

    private final String value;

    ChampData(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return name().toLowerCase();
    }
} public class Champion {

    private List<String> allytips;
    private String blurb;
    private List<String> enemytips;
    private int id;
    private Image image;
    private Info info;
    private String key;
    private String lore;
    private String name;
    private String partype;
    private Passive passive;
    private List<Recommended> recommended;
    private List<Skin> skins;
    private List<ChampionSpell> spells;
    private Stats stats;
    private List<String> tags;
    private String title;

    public List<String> getAllytips() {
        return allytips;
    }

    public String getBlurb() {
        return blurb;
    }

    public List<String> getEnemytips() {
        return enemytips;
    }

    public int getId() {
        return id;
    }

    public Image getImage() {
        return image;
    }

    public Info getInfo() {
        return info;
    }

    public String getKey() {
        return key;
    }

    public String getLore() {
        return lore;
    }

    public String getName() {
        return name;
    }

    public String getPartype() {
        return partype;
    }

    public Passive getPassive() {
        return passive;
    }

    public List<Recommended> getRecommended() {
        return recommended;
    }

    public List<Skin> getSkins() {
        return skins;
    }

    public List<ChampionSpell> getSpells() {
        return spells;
    }

    public Stats getStats() {
        return stats;
    }

    public List<String> getTags() {
        return tags;
    }

    public String getTitle() {
        return title;
    }
} public class ChampionList {

    private Map<String, Champion> data;
    private String format;
    private Map<String, String> keys;
    private String type;
    private String version;

    public Map<String, Champion> getData() {
        return data;
    }

    public String getFormat() {
        return format;
    }

    public Map<String, String> getKeys() {
        return keys;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }
} public class ChampionQueryParams implements QueryParams {

    private String locale;
    private String version;
    private boolean dataById;
    private ChampData[] champData;

    private ChampionQueryParams(Builder builder) {
        this.locale = builder.locale;
        this.version = builder.version;
        this.dataById = builder.dataById;
        this.champData = builder.champData;
    }

    @Override
    public Map<String, String> getParams() {
        Map<String, String> map = new HashMap<String, String>();
        if (locale != null) map.put("locale", locale);
        if (version != null) map.put("version", version);
        if (dataById) map.put("dataById", Boolean.toString(dataById));
        if (champData != null) map.put("champData", Joiner.on(",").join(champData));

        return map;
    }

    public static class Builder {
        private String locale;
        private String version;
        private boolean dataById;
        private ChampData[] champData;

        /**
         * @param  locale Locale code for returned data (e.g., en_US, es_ES). If not specified, the default
         *         locale for the region is used.
         */
        public Builder locale(String locale) {
            this.locale = locale;
            return this;
        }

        /**
         * @param   version Data dragon version for returned data. If not specified, the latest version for the region
         *          is used. List of valid versions can be obtained from the /versions endpoint
         *
         * @see     api.Ulti#getStaticVersions()
         */
        public Builder version(String version) {
            this.version = version;
            return this;
        }

        /**
         * @param   dataById If specified as true, the returned data map will use the champions' IDs as the keys.
         *                   If not specified or specified as false, the returned data map will use the champions'
         *                   keys instead.
         */
        public Builder dataById(boolean dataById) {
            this.dataById = dataById;
            return this;
        }

        /**
         * @param   champData Tags to return additional data. Only type, version, data, id, key, name, and title are
         *                    returned by default if this parameter isn't specified. To return all additional data,
         *                    use the tag 'all'.
         *
         * @see     dto.staticdata.champion.ChampData
         */
        public Builder champData(ChampData... champData) {
            this.champData = champData;
            return this;
        }

        public ChampionQueryParams build() {
            return new ChampionQueryParams(this);
        }
    }
} public class Item {

    private String colloq;
    private boolean consumeOnFull;
    private boolean consumed;
    private int depth;
    private String description;
    private List<String> from;
    private Gold gold;
    private String group;
    private boolean hideFromAll;
    private int id;
    private Image image;
    private boolean inStore;
    private List<String> into;
    private Map<String, Boolean> maps;
    private String name;
    private String plaintext;
    private String requiredChampion;
    private MetaData rune;
    private String sanitizedDescription;
    private int specialRecipe;
    private int stacks;
    private BasicDataStats stats;
    private List<String> tags;

    public String getColloq() {
        return colloq;
    }

    public boolean isConsumeOnFull() {
        return consumeOnFull;
    }

    public boolean isConsumed() {
        return consumed;
    }

    public int getDepth() {
        return depth;
    }

    public String getDescription() {
        return description;
    }

    public List<String> getFrom() {
        return from;
    }

    public Gold getGold() {
        return gold;
    }

    public String getGroup() {
        return group;
    }

    public boolean isHideFromAll() {
        return hideFromAll;
    }

    public int getId() {
        return id;
    }

    public Image getImage() {
        return image;
    }

    public boolean isInStore() {
        return inStore;
    }

    public List<String> getInto() {
        return into;
    }

    public Map<String, Boolean> getMaps() {
        return maps;
    }

    public String getName() {
        return name;
    }

    public String getPlaintext() {
        return plaintext;
    }

    public String getRequiredChampion() {
        return requiredChampion;
    }

    public MetaData getRune() {
        return rune;
    }

    public String getSanitizedDescription() {
        return sanitizedDescription;
    }

    public int getSpecialRecipe() {
        return specialRecipe;
    }

    public int getStacks() {
        return stacks;
    }

    public BasicDataStats getStats() {
        return stats;
    }

    public List<String> getTags() {
        return tags;
    }
} public class ItemList {

    private BasicData basic;
    private Map<String, Item> data;
    private List<Group> groups;
    private List<ItemTree> tree;
    private String type;
    private String version;

    public BasicData getBasic() {
        return basic;
    }

    public Map<String, Item> getData() {
        return data;
    }

    public List<Group> getGroups() {
        return groups;
    }

    public List<ItemTree> getTree() {
        return tree;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }
} public enum ItemListData {
    ALL("all"),
    COLLOQ("colloq"),
    CONSUME_ON_FULL("consumeOnFull"),
    CONSUMED("consumed"),
    DEPTH("depth"),
    FROM("from"),
    GOLD("gold"),
    GROUPS("groups"),
    HIDE_FROM_ALL("hideFromAll"),
    IMAGE("image"),
    IN_STORE("inStore"),
    INTO("into"),
    MAPS("maps"),
    REQUIRED_CHAMPION("requiredChampion"),
    SANITIZED_DESCRIPTION("sanitizedChampion"),
    SPECIAL_RECIPE("specialRecipe"),
    STACKS("stacks"),
    STATS("stats"),
    TAGS("tags"),
    TREE("tree");

    private final String value;

    ItemListData(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
} public class ItemQueryParams implements QueryParams {
    private String locale;
    private String version;
    private ItemListData[] itemListData;

    private ItemQueryParams(Builder builder) {
        this.locale = builder.locale;
        this.version = builder.version;
        this.itemListData = builder.itemListData;
    }

    @Override
    public Map<String, String> getParams() {
        Map<String, String> map = new HashMap<String, String>();
        if (locale != null) map.put("locale", locale);
        if (version != null) map.put("version", version);
        if (itemListData != null) map.put("itemListData", Joiner.on(",").join(itemListData));

        return map;
    }

    public static class Builder {
        private String locale;
        private String version;
        private ItemListData[] itemListData;

        /**
         * @param   locale Locale code for returned data (e.g., en_US, es_ES). If not specified, the default
         *          locale for the region is used.
         */
        public Builder locale(String locale) {
            this.locale = locale;
            return this;
        }

        /**
         * @param   version Data dragon version for returned data. If not specified, the latest version for the region
         *          is used. List of valid versions can be obtained from the /versions endpoint
         *
         * @see     api.Ulti#getStaticVersions()
         */
        public Builder version(String version) {
            this.version = version;
            return this;
        }

        /**
         * @param   itemListData Tags to return additional data. Only type, version, basic, data, id, name, plaintext,
         *                       group, and description are returned by default if this parameter isn't specified. To
         *                       return all additional data, use the tag 'all'.
         *
         * @see     dto.staticdata.item.ItemListData
         */
        public Builder itemListData(ItemListData... itemListData) {
            this.itemListData = itemListData;
            return this;
        }

        public ItemQueryParams build() {
            return new ItemQueryParams(this);
        }
    }
} public class Mastery {

    private List<String> description;
    private int id;
    private Image image;
    private String name;
    private String prereq;
    private int ranks;
    private List<String> sanitizedDescription;

    public List<String> getDescription() {
        return description;
    }

    public int getId() {
        return id;
    }

    public Image getImage() {
        return image;
    }

    public String getName() {
        return name;
    }

    public String getPrereq() {
        return prereq;
    }

    public int getRanks() {
        return ranks;
    }

    public List<String> getSanitizedDescription() {
        return sanitizedDescription;
    }
} public class MasteryList {

    private Map<String, Mastery> data;
    private MasteryTree tree;
    private String type;
    private String version;

    public Map<String, Mastery> getData() {
        return data;
    }

    public MasteryTree getTree() {
        return tree;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }
} public enum MasteryListData {
    ALL("all"),
    IMAGE("image"),
    PREREQ("prereq"),
    RANKS("ranks"),
    SANITIZED_DESCRIPTION("sanitizedDescription"),
    TREE("tree");

    private final String value;

    MasteryListData(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
} public class MasteryQueryParams implements QueryParams {
    private String locale;
    private String version;
    private MasteryListData[] masteryListData;

    private MasteryQueryParams(Builder builder) {
        this.locale = builder.locale;
        this.version = builder.version;
        this.masteryListData = builder.masteryListData;
    }

    @Override
    public Map<String, String> getParams() {
        Map<String, String> map = new HashMap<String, String>();
        if (locale != null) map.put("locale", locale);
        if (version != null) map.put("version", version);
        if (masteryListData != null) map.put("masteryListData", Joiner.on(",").join(masteryListData));

        return map;
    }

    public static class Builder {
        private String locale;
        private String version;
        private MasteryListData[] masteryListData;

        /**
         * @param   locale Locale code for returned data (e.g., en_US, es_ES). If not specified, the default
         *          locale for the region is used.
         */
        public Builder locale(String locale) {
            this.locale = locale;
            return this;
        }

        /**
         * @param   version Data dragon version for returned data. If not specified, the latest version for the region
         *          is used. List of valid versions can be obtained from the /versions endpoint
         *
         * @see     api.Ulti#getStaticVersions()
         */
        public Builder version(String version) {
            this.version = version;
            return this;
        }

        /**
         * @param   masteryListData Tags to return additional data. Only type, version, data, id, name, and description
         *                          are returned by default if this parameter isn't specified. To return all additional
         *                          data, use the tag 'all'.
         *
         * @see     dto.staticdata.mastery.MasteryListData
         */
        public Builder masteryListData(MasteryListData... masteryListData) {
            this.masteryListData = masteryListData;
            return this;
        }

        public MasteryQueryParams build() {
            return new MasteryQueryParams(this);
        }
    }
} public class Realm {

    private String cdn;
    private String css;
    private String dd;
    private String l;
    private String lg;
    private Map<String, String> n;
    private int profileiconmax;
    private String store;
    private String v;

    /**
     * @return  the base CDN url
     */
    public String getCdn() {
        return cdn;
    }

    /**
     * @return  latest changed version of Dragon Magic's css file
     */
    public String getCss() {
        return css;
    }

    /**
     * @return  latest changed version of Dragon Magic
     */
    public String getDd() {
        return dd;
    }

    /**
     * @return  default language for this realm
     */
    public String getL() {
        return l;
    }

    /**
     * @return  legacy script mode for IE6 or older :/
     */
    public String getLg() {
        return lg;
    }

    /**
     * @return  a {@link java.util.Map} of the latest changed version for each data type listed
     */
    public Map<String, String> getN() {
        return n;
    }

    /**
     * Special behavior number identifying the largest profileicon id that can be used under 500.
     * Any profileicon that is requested between this number and 500 should be mapped to 0.
     */
    public int getProfileiconmax() {
        return profileiconmax;
    }

    /**
     * @return  additional api data drawn from other sources that may be related to data dragon functionality.
     */
    public String getStore() {
        return store;
    }

    /**
     * @return  current version of this file for this realm
     */
    public String getV() {
        return v;
    }
} public class Rune {

    private String colloq;
    private boolean consumeOnFull;
    private boolean consumed;
    private int depth;
    private String description;
    private List<String> from;
    private Gold gold;
    private String group;
    private boolean hideFromAll;
    private int id;
    private Image image;
    private boolean inStore;
    private List<String> into;
    private Map<String, Boolean> maps;
    private String name;
    private String plaintext;
    private String requiredChampion;
    private MetaData rune;
    private String sanitizedDescription;
    private int specialRecipe;
    private int stacks;
    private BasicDataStats stats;
    private List<String> tags;

    public String getColloq() {
        return colloq;
    }

    public boolean isConsumeOnFull() {
        return consumeOnFull;
    }

    public boolean isConsumed() {
        return consumed;
    }

    public int getDepth() {
        return depth;
    }

    public String getDescription() {
        return description;
    }

    public List<String> getFrom() {
        return from;
    }

    public Gold getGold() {
        return gold;
    }

    public String getGroup() {
        return group;
    }

    public int getId() {
        return id;
    }

    public boolean isHideFromAll() {
        return hideFromAll;
    }

    public Image getImage() {
        return image;
    }

    public boolean isInStore() {
        return inStore;
    }

    public Map<String, Boolean> getMaps() {
        return maps;
    }

    public List<String> getInto() {
        return into;
    }

    public String getName() {
        return name;
    }

    public String getPlaintext() {
        return plaintext;
    }

    public MetaData getRune() {
        return rune;
    }

    public String getRequiredChampion() {
        return requiredChampion;
    }

    public String getSanitizedDescription() {
        return sanitizedDescription;
    }

    public int getSpecialRecipe() {
        return specialRecipe;
    }

    public int getStacks() {
        return stacks;
    }

    public BasicDataStats getStats() {
        return stats;
    }

    public List<String> getTags() {
        return tags;
    }
} public class RuneList {

    private BasicData basic;
    private Map<String, Rune> data;
    private String type;
    private String version;

    public BasicData getBasic() {
        return basic;
    }

    public Map<String, Rune> getData() {
        return data;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }
} public enum RuneListData {
    ALL("all"),
    COLLOQ("colloq"),
    CONSUME_ON_FULL("consumeOnFull"),
    CONSUMED("consumed"),
    DEPTH("depth"),
    FROM("from"),
    GOLD("gold"),
    GROUPS("groups"),
    HIDE_FROM_ALL("hideFromAll"),
    IMAGE("image"),
    IN_STORE("inStore"),
    INTO("into"),
    MAPS("maps"),
    REQUIRED_CHAMPION("requiredChampion"),
    SANITIZED_DESCRIPTION("sanitizedChampion"),
    SPECIAL_RECIPE("specialRecipe"),
    STACKS("stacks"),
    STATS("stats"),
    TAGS("tags");

    private final String value;

    RuneListData(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
} public class RuneQueryParams implements QueryParams {
    private String locale;
    private String version;
    private RuneListData[] runeListData;

    private RuneQueryParams(Builder builder) {
        this.locale = builder.locale;
        this.version = builder.version;
        this.runeListData = builder.runeListData;
    }

    @Override
    public Map<String, String> getParams() {
        Map<String, String> map = new HashMap<String, String>();
        if (locale != null) map.put("locale", locale);
        if (version != null) map.put("version", version);
        if (runeListData != null) map.put("runeListData", Joiner.on(",").join(runeListData));

        return map;
    }

    public static class Builder {
        private String locale;
        private String version;
        private RuneListData[] runeListData;

        /**
         * @param   locale Locale code for returned data (e.g., en_US, es_ES). If not specified, the default
         *          locale for the region is used.
         */
        public Builder locale(String locale) {
            this.locale = locale;
            return this;
        }

        /**
         * @param   version Data dragon version for returned data. If not specified, the latest version for the region
         *          is used. List of valid versions can be obtained from the /versions endpoint
         *
         * @see     api.Ulti#getStaticVersions()
         */
        public Builder version(String version) {
            this.version = version;
            return this;
        }

        /**
         * @param   runeListData Tags to return additional data. Only type, version, data, id, name, rune, and
         *                       description are returned by default if this parameter isn't specified. To return all
         *                       additional data, use the tag 'all'.
         *
         * @see     dto.staticdata.rune.RuneListData
         */
        public Builder runeListData(RuneListData... runeListData) {
            this.runeListData = runeListData;
            return this;
        }

        public RuneQueryParams build() {
            return new RuneQueryParams(this);
        }
    }
} public enum SpellData {
    ALL("all"),
    COOLDOWN("cooldown"),
    COOLDOWN_BURN("cooldownBurn"),
    COST("cost"),
    COST_BURN("costBurn"),
    EFFECT("effect"),
    EFFECT_BURN("effectBurn"),
    IMAGE("image"),
    KEY("key"),
    LEVELTIP("leveltip"),
    MAXRANK("maxrank"),
    MODES("modes"),
    RANGE("range"),
    RANGE_BURN("rangeBurn"),
    RESOURCE("resource"),
    SANITIZED_DESCRIPTION("sanitizedDescription"),
    SANITIZED_TOOLTIP("sanitizedTooltip"),
    TOOLTIP("tooltip"),
    VARS("vars");

    private final String value;

    SpellData(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
} public class SummonerSpell {

    private List<Double> cooldown;
    private String cooldownBurn;
    private List<Integer> cost;
    private String costBurn;
    private String costType;
    private String description;
    private List<List<Double>> effect;
    private List<String> effectBurn;
    private int id;
    private Image image;
    private String key;
    private LevelTip leveltip;
    private int maxrank;
    private List<String> modes;
    private String name;
    private Object range;
    private String rangeBurn;
    private String resource;
    private String sanitizedDescription;
    private String sanitizedTooltip;
    private int summonerLevel;
    private String tooltip;
    private List<SpellVars> vars;

    public List<Double> getCooldown() {
        return cooldown;
    }

    public String getCooldownBurn() {
        return cooldownBurn;
    }

    public List<Integer> getCost() {
        return cost;
    }

    public String getCostBurn() {
        return costBurn;
    }

    public String getCostType() {
        return costType;
    }

    public String getDescription() {
        return description;
    }

    public List<List<Double>> getEffect() {
        return effect;
    }

    public List<String> getEffectBurn() {
        return effectBurn;
    }

    public int getId() {
        return id;
    }

    public Image getImage() {
        return image;
    }

    public String getKey() {
        return key;
    }

    public LevelTip getLeveltip() {
        return leveltip;
    }

    public int getMaxrank() {
        return maxrank;
    }

    public List<String> getModes() {
        return modes;
    }

    public String getName() {
        return name;
    }

    /**
     * @return  either a {@link java.util.List} of {@link java.lang.Integer}, or a {@link java.lang.String} containing
     *          'self' for spells that target one's own champion
     */
    public Object getRange() {
        return range;
    }

    public String getRangeBurn() {
        return rangeBurn;
    }

    public String getResource() {
        return resource;
    }

    public String getSanitizedDescription() {
        return sanitizedDescription;
    }

    public String getSanitizedTooltip() {
        return sanitizedTooltip;
    }

    public int getSummonerLevel() {
        return summonerLevel;
    }

    public String getTooltip() {
        return tooltip;
    }

    public List<SpellVars> getVars() {
        return vars;
    }
} public class SummonerSpellList {

    private Map<String, SummonerSpell> data;
    private String type;
    private String version;

    public Map<String, SummonerSpell> getData() {
        return data;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }
} public class SummonerSpellQueryParams implements QueryParams {
    private String locale;
    private String version;
    private boolean dataById;
    private SpellData[] spellData;

    private SummonerSpellQueryParams(Builder builder) {
        this.locale = builder.locale;
        this.version = builder.version;
        this.dataById = builder.dataById;
        this.spellData = builder.spellData;
    }

    @Override
    public Map<String, String> getParams() {
        Map<String, String> map = new HashMap<String, String>();
        if (locale != null) map.put("locale", locale);
        if (version != null) map.put("version", version);
        if (dataById) map.put("dataById", Boolean.toString(dataById));
        if (spellData != null) map.put("spellData", Joiner.on(",").join(spellData));

        return map;
    }

    public static class Builder {
        private String locale;
        private String version;
        private boolean dataById;
        private SpellData[] spellData;

        /**
         * @param   locale Locale code for returned data (e.g., en_US, es_ES). If not specified, the default
         *          locale for the region is used.
         */
        public Builder locale(String locale) {
            this.locale = locale;
            return this;
        }

        /**
         * @param   version Data dragon version for returned data. If not specified, the latest version for the region
         *          is used. List of valid versions can be obtained from the /versions endpoint
         *
         * @see     api.Ulti#getStaticVersions()
         */
        public Builder version(String version) {
            this.version = version;
            return this;
        }

        /**
         * @param   dataById If specified as true, the returned data map will use the champions' IDs as the keys.
         *                   If not specified or specified as false, the returned data map will use the champions'
         *                   keys instead.
         */
        public Builder dataById(boolean dataById) {
            this.dataById = dataById;
            return this;
        }

        /**
         * @param   spellData Tags to return additional data. Only type, version, data, id, key, name, description,
         *                    and summonerLevel are returned by default if this parameter isn't specified. To return
         *                    all additional data, use the tag 'all'.
         *
         * @see     dto.staticdata.summonerspell.SpellData
         */
        public Builder spellData(SpellData... spellData) {
            this.spellData = spellData;
            return this;
        }

        public SummonerSpellQueryParams build() {
            return new SummonerSpellQueryParams(this);
        }
    }
}
import dto.staticdata.champion.ChampData;
import dto.staticdata.champion.Champion;
import dto.staticdata.champion.ChampionList;
import dto.staticdata.champion.ChampionQueryParams;
import dto.staticdata.item.Item;
import dto.staticdata.item.ItemList;
import dto.staticdata.item.ItemListData;
import dto.staticdata.item.ItemQueryParams;
import dto.staticdata.mastery.Mastery;
import dto.staticdata.mastery.MasteryList;
import dto.staticdata.mastery.MasteryListData;
import dto.staticdata.mastery.MasteryQueryParams;
import dto.staticdata.realm.Realm;
import dto.staticdata.rune.Rune;
import dto.staticdata.rune.RuneList;
import dto.staticdata.rune.RuneListData;
import dto.staticdata.rune.RuneQueryParams;
import dto.staticdata.summonerspell.SpellData;
import dto.staticdata.summonerspell.SummonerSpell;
import dto.staticdata.summonerspell.SummonerSpellList;
import dto.staticdata.summonerspell.SummonerSpellQueryParams;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import java.util.Iterator;
import java.util.List;
     * @see api.Ulti#getStaticItemList()
     */
    @Test
    public void testGetStaticItemList() {
        ItemList itemList = ulti.getStaticItemList();
        Assert.assertNotNull(itemList);
    }

    /**
     * @see api.Ulti#getStaticItemList(dto.staticdata.item.ItemQueryParams)
     */
    @Test
    public void testGetStaticItemListWithParams() {
        ItemQueryParams itemQueryParams = new ItemQueryParams.Builder()
                .locale(TEST_LOCALE)
                .version(TEST_VERSION)
                .itemListData(ItemListData.ALL)
                .build();

        ItemList itemList = ulti.getStaticItemList(itemQueryParams);
        Assert.assertNotNull(itemList);
    }

    /**
     * @see Ulti#getStaticItem(int)
     */
    @Test
    public void testGetStaticItem() {
        ItemList itemList = ulti.getStaticItemList();
        Iterator<Item> iterator = itemList.getData().values().iterator();

        while (iterator.hasNext()) {
            Item item = iterator.next();
            Assert.assertNotNull(ulti.getStaticItem(item.getId()));
        }
    }

    /**
     * @see api.Ulti#getStaticItem(int, dto.staticdata.item.ItemQueryParams)
     */
    @Test
    public void testGetStaticItemWithParams() {
        ItemList itemList = ulti.getStaticItemList();
        Iterator<Item> iterator = itemList.getData().values().iterator();

        ItemQueryParams itemQueryParams = new ItemQueryParams.Builder()
                .locale(TEST_LOCALE)
                .version(TEST_VERSION)
                .itemListData(ItemListData.COLLOQ, ItemListData.CONSUME_ON_FULL)
                .build();

        while (iterator.hasNext()) {
            Item item = iterator.next();
            Assert.assertNotNull(ulti.getStaticItem(item.getId(), itemQueryParams));
        }
    }

    /**
     * @see api.Ulti#getStaticMasteryList()
     */
    @Test
    public void testGetStaticMasteryList() {
        MasteryList masteryList = ulti.getStaticMasteryList();
        Assert.assertNotNull(masteryList);
    }

    /**
     * @see api.Ulti#getStaticMasteryList(dto.staticdata.mastery.MasteryQueryParams
     */
    @Test
    public void testGetStaticMasteryListWithParams() {
        MasteryQueryParams masteryQueryParams = new MasteryQueryParams.Builder()
                .locale(TEST_LOCALE)
                .version(TEST_VERSION)
                .masteryListData(MasteryListData.ALL)
                .build();

        MasteryList masteryList = ulti.getStaticMasteryList(masteryQueryParams);
        Assert.assertNotNull(masteryList);
    }

    /**
     * @see Ulti#getStaticMastery(int)
     */
    @Test
    public void testGetStaticMastery() {
        MasteryList masteryList = ulti.getStaticMasteryList();
        Iterator<Mastery> iterator = masteryList.getData().values().iterator();

        while (iterator.hasNext()) {
            Mastery mastery = iterator.next();
            Assert.assertNotNull(ulti.getStaticMastery(mastery.getId()));
        }
    }

    /**
     * @see api.Ulti#getStaticMastery(int, dto.staticdata.mastery.MasteryQueryParams)
     */
    @Test
    public void testGetStaticMasteryWithParams() {
        MasteryList masteryList = ulti.getStaticMasteryList();
        Iterator<Mastery> iterator = masteryList.getData().values().iterator();

        MasteryQueryParams masteryQueryParams = new MasteryQueryParams.Builder()
                .locale(TEST_LOCALE)
                .version(TEST_VERSION)
                .masteryListData(MasteryListData.IMAGE, MasteryListData.SANITIZED_DESCRIPTION)
                .build();

        while (iterator.hasNext()) {
            Mastery mastery = iterator.next();
            Assert.assertNotNull(ulti.getStaticMastery(mastery.getId(), masteryQueryParams));
        }
    }

    /**
     * @see api.Ulti#getStaticRealm()
     */
    @Test
    public void testGetStaticRealm() {
        Realm r = ulti.getStaticRealm();