package net.w_horse.excelpojo.xml;

import static org.junit.Assert.assertEquals;

import java.io.FileInputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import net.w_horse.excelpojo.AbstractTest;
import net.w_horse.excelpojo.ExcelPOJOBridge;
import net.w_horse.excelpojo.ExcelPOJOException;
import net.w_horse.excelpojo.excel.CellNotFoundException;

import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import test.annotation.AnnotationTestElementReadTableUseNone;
import test.xml.DataFormatTest;
import test.xml.DateFormatTest;
import test.xml.XMLTest;
import test.xml.XMLTestElement;


public class ExcelPOJOXmlParserTest extends AbstractTest {
	/**
	 * XMLの定義による基本的な読み書きのテスト
	 * 一通りのタイプ・型についての確認
	 *
	 */
	@Test
	public void testReadAndSaveBasic() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveBasic");
		XMLTest targetBean = (XMLTest) bridge.load("./files/upload/ParserTest.xls", "基本");

		assertEquals("基本（取得）：LabeledCell：String", "文字列１", targetBean.getStringField4LabeledCell1());
		assertEquals("基本（取得）：LabeledCell：int", 45, targetBean.getIntField4LabeledCell1());
		assertEquals("基本（取得）：LabeledCell：boolean", true, targetBean.isBooleanField4LabeledCell1());
		assertEquals("基本（取得）：LabeledCell：double", 78.56, targetBean.getDoubleField4LabeledCell1(), 0.001);
		assertEquals("基本（取得）：LabeledCell：日付（文字列）", "2010/06/18", targetBean.getDateField4LabeledCell1());

		assertEquals("基本（取得）：PointedCell：String", "位置による検索：文字列", targetBean.getStringField4PointedCell1());
		assertEquals("基本（取得）：PointedCell：int", 234, targetBean.getIntField4PointedCell1());
		assertEquals("基本（取得）：PointedCell：boolean", false, targetBean.isBooleanField4PointedCell1());
		assertEquals("基本（取得）：PointedCell：double", 963.2, targetBean.getDoubleField4PointedCell1(), 0.001);
		assertEquals("基本（取得）：PointedCell：日付（文字列）", "2010/06/22", targetBean.getDateField4PointedCell1());

		assertEquals("基本（取得）：ConstantValue：String", "固定値：文字列", targetBean.getStringField4ConstantValue1());
		assertEquals("基本（取得）：ConstantValue：int", 258, targetBean.getIntField4ConstantValue1());
		assertEquals("基本（取得）：ConstantValue：boolean", false, targetBean.isBooleanField4ConstantValue1());
		assertEquals("基本（取得）：ConstantValue：double", 3.14, targetBean.getDoubleField4ConstantValue1(), 0.001);

		Map<String, String> countMembersMap = targetBean.getMapField4MappedCell1();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, countMembersMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, countMembersMap.keySet().size());

		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"0", "0", "1", "4"};
		int i = 0;
		for (String key : countMembersMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], countMembersMap.get(key));
			i++;
		}

		List<XMLTestElement> listElm = targetBean.getList4VerticalRepeats1();
		assertEquals("基本（取得）：VerticalRepeats：List", ArrayList.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"160", "182", "165", "177"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		XMLTestElement[] arrElm = targetBean.getArr4VerticalRepeats1();
		assertEquals("基本（取得）：VerticalRepeats：Array", XMLTestElement[].class, arrElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 2, arrElm.length);

		elm = arrElm[0];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "篠原", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "まつ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 156.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"90", "56", "81", "23"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = arrElm[1];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "平", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "清盛", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 168.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"112", "186", "78", "140"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		listElm = targetBean.getList4HorizontalRepeats1();
		assertEquals("基本（取得）：VerticalRepeats：List", ArrayList.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"160", "182", "165", "177"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}


		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャH", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		arrElm = targetBean.getArr4HorizontalRepeats1();
		assertEquals("基本（取得）：VerticalRepeats：Array", XMLTestElement[].class, arrElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 2, arrElm.length);

		elm = arrElm[0];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "篠原H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "まつH", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 156.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"90", "56", "81", "23"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = arrElm[1];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "平H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "清盛H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 168.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"112", "186", "78", "140"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}



		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_基本.xls",
				targetBean);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_基本.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：LabeledCell：String", "文字列１", getCellValue(sheet, 42, 9, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：LabeledCell：int", 45, getCellValue(sheet, 43, 9, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：LabeledCell：boolean", true, getCellValue(sheet, 44, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：LabeledCell：double", 78.56, (Double)getCellValue(sheet, 45, 9, CELL_TYPE_DOUBLE), 0.001);
			assertEquals("基本（書き込み）：LabeledCell：日付（文字列）", "2010/06/18", getCellValue(sheet, 46, 9, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：PointedCell：String", "位置による検索：文字列", getCellValue(sheet, 14, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：PointedCell：int",234, getCellValue(sheet, 15, 3, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：PointedCell：boolean",false, getCellValue(sheet, 16, 3, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：PointedCell：double",963.2, (Double)getCellValue(sheet, 17, 3, CELL_TYPE_DOUBLE), 0.001);
			assertEquals("基本（書き込み）：PointedCell：日付（文字列）","2010/06/22", getCellValue(sheet, 18, 3, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 21, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","0",   getCellValue(sheet, 22, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 21, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","0",   getCellValue(sheet, 22, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 21, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","1",   getCellValue(sheet, 22, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 21, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","4",   getCellValue(sheet, 22, 5, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 3, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 3, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 3, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 3, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 3, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 3, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 2, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 2, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 2, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 2, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 3, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 3, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 3, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 3, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 4, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 4, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 4, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 4, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 4, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 4, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 4, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 4, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 4, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 4, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 5, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 5, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 5, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 5, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 5, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 5, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 5, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 5, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 5, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 5, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 6, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 6, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 6, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 6, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 6, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 6, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 6, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 6, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 6, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 6, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 29, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "篠原", getCellValue(sheet, 29, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "まつ", getCellValue(sheet, 29, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 29, 7, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 156.0, (Double)getCellValue(sheet, 29, 8, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", getCellValue(sheet, 29, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 28, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 28, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 28, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 28, 17, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","90", getCellValue(sheet, 29, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","56", getCellValue(sheet, 29, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","81", getCellValue(sheet, 29, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","23", getCellValue(sheet, 29, 17, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 30, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "平", getCellValue(sheet, 30, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "清盛", getCellValue(sheet, 30, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 30, 7, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 168.5, (Double)getCellValue(sheet, 30, 8, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", getCellValue(sheet, 30, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","112", getCellValue(sheet, 30, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","186", getCellValue(sheet, 30, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","78", getCellValue(sheet, 30, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","140", getCellValue(sheet, 30, 17, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 50, 3, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田H", getCellValue(sheet, 53, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄H", getCellValue(sheet, 54, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 3, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 59, 3, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 52, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 62, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 63, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 64, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 65, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 62, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 63, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 64, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 65, 3, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 50, 4, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田H", getCellValue(sheet, 53, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長H", getCellValue(sheet, 54, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 60, 4, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 59, 4, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 52, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 62, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 63, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 64, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 65, 4, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 50, 5, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川H", getCellValue(sheet, 53, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康H", getCellValue(sheet, 54, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 5, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 59, 5, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 52, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 62, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 63, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 64, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 65, 5, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 50, 6, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川H", getCellValue(sheet, 53, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャH", getCellValue(sheet, 54, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 59, 6, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 52, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 62, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 63, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 64, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 65, 6, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 70, 4, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "篠原H", getCellValue(sheet, 73, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "まつH", getCellValue(sheet, 74, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 71, 4, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 156.0, (Double)getCellValue(sheet, 80, 4, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", getCellValue(sheet, 72, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 82, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 83, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 84, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 85, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","90", getCellValue(sheet, 82, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","56", getCellValue(sheet, 83, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","81", getCellValue(sheet, 84, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","23", getCellValue(sheet, 85, 4, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 70, 5, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "平H", getCellValue(sheet, 73, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "清盛H", getCellValue(sheet, 74, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 71, 5, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 168.5, (Double)getCellValue(sheet, 80, 5, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", getCellValue(sheet, 72, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","112", getCellValue(sheet, 82, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","186", getCellValue(sheet, 83, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","78", getCellValue(sheet, 84, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","140", getCellValue(sheet, 85, 5, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義による数値型のフォーマットによる差異のテスト
	 *
	 */
	@Test
	public void testDataFormat() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testDataFormat");
		DataFormatTest targetBean = (DataFormatTest) bridge.load("./files/upload/ParserTest.xls", "各セルタイプ");

		assertEquals("各セルタイプ 01",1, targetBean.getData1());
		assertEquals("各セルタイプ 02","文字列", targetBean.getData2());
		assertEquals("各セルタイプ 03",-1234, targetBean.getData3());
		assertEquals("各セルタイプ 04",-1234, targetBean.getData4());
		assertEquals("各セルタイプ 05",-1234, targetBean.getData5());
		assertEquals("各セルタイプ 06",-1234, targetBean.getData6());
		assertEquals("各セルタイプ 07",-1234, targetBean.getData7());
		assertEquals("各セルタイプ 08",-1234, targetBean.getData8());
		assertEquals("各セルタイプ 09",-1234, targetBean.getData9());
		assertEquals("各セルタイプ 10",-1234.56, targetBean.getData10(),0.000000000000001);
		assertEquals("各セルタイプ 11",-1234.56, targetBean.getData11(),0.000000000000001);
		assertEquals("各セルタイプ 12",-1234.56, targetBean.getData12(),0.000000000000001);
		assertEquals("各セルタイプ 13",-1234.56, targetBean.getData13(),0.000000000000001);
		assertEquals("各セルタイプ 14",-1234.56, targetBean.getData14(),0.000000000000001);
		assertEquals("各セルタイプ 15",-1234.56, targetBean.getData15(),0.000000000000001);
		assertEquals("各セルタイプ 16",-1234.56, targetBean.getData16(),0.000000000000001);
		assertEquals("各セルタイプ 17",-123456, targetBean.getData17());
		assertEquals("各セルタイプ 18",-123456, targetBean.getData18());
		assertEquals("各セルタイプ 19",-123456, targetBean.getData19());
		assertEquals("各セルタイプ 20",-123456, targetBean.getData20());
		assertEquals("各セルタイプ 21",-123456, targetBean.getData21());
		assertEquals("各セルタイプ 22",-123456.78, targetBean.getData22(),0.000000000000001);
		assertEquals("各セルタイプ 23",-123456.78, targetBean.getData23(),0.000000000000001);
		assertEquals("各セルタイプ 24",-123456.78, targetBean.getData24(),0.000000000000001);
		assertEquals("各セルタイプ 25",-123456.78, targetBean.getData25(),0.000000000000001);
		assertEquals("各セルタイプ 26",-123456.78, targetBean.getData26(),0.000000000000001);
		assertEquals("各セルタイプ 27",-123456, targetBean.getData27());
		assertEquals("各セルタイプ 28",-123456, targetBean.getData28());
		assertEquals("各セルタイプ 29",-123456.78, targetBean.getData29(),0.000000000000001);
		assertEquals("各セルタイプ 30",-123456.78, targetBean.getData30(),0.000000000000001);
		assertEquals("各セルタイプ 31",0.1234, targetBean.getData31(),0.000000000000001);
		assertEquals("各セルタイプ 32",0.1234, targetBean.getData32(),0.000000000000001);
		assertEquals("各セルタイプ 33",2, targetBean.getData33());
		assertEquals("各セルタイプ 34","文字列_付加文字列", targetBean.getData34());
		assertEquals("各セルタイプ 35",-1234, targetBean.getData35());
		assertEquals("各セルタイプ 36","2010年6月23日", targetBean.getData36());
		assertEquals("各セルタイプ 37",new BigInteger("-12345678901234500000"), targetBean.getData37());
		assertEquals("各セルタイプ 38",-1.23456789012345E12, targetBean.getData38(),0.000000000000001);
	}

	/**
	 * XML定義による日付型のフォーマットの差異テスト
	 *
	 */
	@Test
	public void testDateFormat() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testDateFormat");
		DateFormatTest targetBean = (DateFormatTest) bridge.load("./files/upload/ParserTest.xls", "日付フォーマット");

		assertEquals("日付フォーマット 01", "2010/1/2",targetBean.getDateStr1());
		assertEquals("日付フォーマット 02", "2-Jan-10",targetBean.getDateStr2());
		assertEquals("日付フォーマット 03", "2-Jan",targetBean.getDateStr3());
		assertEquals("日付フォーマット 04", "Jan-10",targetBean.getDateStr4());
		assertEquals("日付フォーマット 05", "9:03 AM",targetBean.getDateStr5());
		assertEquals("日付フォーマット 06", "9:03:04 AM",targetBean.getDateStr6());
		assertEquals("日付フォーマット 07", "9:03",targetBean.getDateStr7());
		assertEquals("日付フォーマット 08", "9:03:04",targetBean.getDateStr8());
		assertEquals("日付フォーマット 09", "2010/1/2 9:03",targetBean.getDateStr9());
		assertEquals("日付フォーマット 10", "1/2/10",targetBean.getDateStr10());
		assertEquals("日付フォーマット 11", "2010年1月2日",targetBean.getDateStr11());
		assertEquals("日付フォーマット 12", "9時03分",targetBean.getDateStr12());
		assertEquals("日付フォーマット 13", "9時03分04秒",targetBean.getDateStr13());
		assertEquals("日付フォーマット 14", "03:04",targetBean.getDateStr14());
		assertEquals("日付フォーマット 15", "03:04.0",targetBean.getDateStr15());
		assertEquals("日付フォーマット 16", "2010年1月",targetBean.getDateStr16());
		assertEquals("日付フォーマット 17", "1月2日",targetBean.getDateStr17());
		assertEquals("日付フォーマット 18", "H22.1.2",targetBean.getDateStr18());
		assertEquals("日付フォーマット 19", "平成22年1月2日",targetBean.getDateStr19());
		assertEquals("日付フォーマット 20", "2010/01/02",targetBean.getDateStr20());
		assertEquals("日付フォーマット 21", "2010/01/02",targetBean.getDateStr21());
		assertEquals("日付フォーマット 22", Double.parseDouble("40180.3771296296"),Double.parseDouble(targetBean.getDateStr22()), 0.0000000001);
		assertEquals("日付フォーマット 23", Double.parseDouble("40180.3771296296"),Double.parseDouble(targetBean.getDateStr23()), 0.0000000001);
		assertEquals("日付フォーマット 24", Double.parseDouble("40180.3771296296"),Double.parseDouble(targetBean.getDateStr24()), 0.0000000001);
		assertEquals("日付フォーマット 25", Double.parseDouble("40180.3771296296"),Double.parseDouble(targetBean.getDateStr25()), 0.0000000001);
		assertEquals("日付フォーマット 26", Double.parseDouble("40180.3771296296"),Double.parseDouble(targetBean.getDateStr26()), 0.0000000001);
		assertEquals("日付フォーマット 27", "2010/01/02",targetBean.getDateStr27());
		assertEquals("日付フォーマット 28", "2010/01/02",targetBean.getDateStr28());
		assertEquals("日付フォーマット 29", "2010/01/02",targetBean.getDateStr29());
		assertEquals("日付フォーマット 30", "2010/01/02",targetBean.getDateStr30());
		assertEquals("日付フォーマット 31", "2010/01/02",targetBean.getDateStr31());
		assertEquals("日付フォーマット 32", "2010/01/02",targetBean.getDateStr32());
		assertEquals("日付フォーマット 33", "2010/01/02",targetBean.getDateStr33());
		assertEquals("日付フォーマット 34", "2010/01/02",targetBean.getDateStr34());
		assertEquals("日付フォーマット 35", "2010/01/02",targetBean.getDateStr35());
		assertEquals("日付フォーマット 36", "2010/01/02",targetBean.getDateStr36());
		assertEquals("日付フォーマット 37", "2010/01/02",targetBean.getDateStr37());
		assertEquals("日付フォーマット 38", Double.parseDouble("40180.3771296296"),Double.parseDouble(targetBean.getDateStr38()), 0.0000000001);
		assertEquals("日付フォーマット 39", "2010/01/02",targetBean.getDateStr39());
		assertEquals("日付フォーマット 40", "2010/06/18",targetBean.getDateStr40());

	}

	/**
	 * XML定義による表の直接的な読み書きのテスト
	 * 縦方向にレコードが繰り返されるケース
	 * Listによる取得
	 *
	 */
	@Test
	public void testReadAndSaveTableDirectly1() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableDirectly1");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：List", Vector.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_直接表読み込み１.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み１.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 3, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 3, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 3, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 3, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 3, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 3, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 2, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 2, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 2, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 2, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 3, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 3, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 3, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 3, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 4, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 4, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 4, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 4, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 4, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 4, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 4, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 4, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 4, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 4, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 5, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 5, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 5, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 5, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 5, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 5, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 5, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 5, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 5, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 5, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 6, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 6, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 6, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 6, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 6, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 6, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 6, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 6, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 6, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 6, 16, CELL_TYPE_DATE_STR));

		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義による表の直接的な読み書きのテスト
	 * 縦方向にレコードが繰り返されるケース
	 * 配列による取得
	 *
	 */
	@Test
	public void testReadAndSaveTableDirectly2() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableDirectly2");
		XMLTestElement[] arrElm = (XMLTestElement[]) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：Array", XMLTestElement[].class, arrElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 2, arrElm.length);

		XMLTestElement elm = arrElm[0];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "篠原", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "まつ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 156.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"90", "56", "81", "23"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = arrElm[1];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "平", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "清盛", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 168.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"112", "186", "78", "140"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_直接表読み込み２.xls",
				arrElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み２.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 29, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "篠原", getCellValue(sheet, 29, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "まつ", getCellValue(sheet, 29, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 29, 7, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 156.0, (Double)getCellValue(sheet, 29, 8, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", getCellValue(sheet, 29, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 28, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 28, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 28, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 28, 17, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","90", getCellValue(sheet, 29, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","56", getCellValue(sheet, 29, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","81", getCellValue(sheet, 29, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","23", getCellValue(sheet, 29, 17, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 30, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "平", getCellValue(sheet, 30, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "清盛", getCellValue(sheet, 30, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 30, 7, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 168.5, (Double)getCellValue(sheet, 30, 8, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", getCellValue(sheet, 30, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","112", getCellValue(sheet, 30, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","186", getCellValue(sheet, 30, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","78", getCellValue(sheet, 30, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","140", getCellValue(sheet, 30, 17, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義による表の直接的な読み書きのテスト
	 * 横方向にレコードが繰り返されるケース
	 * Listによる取得
	 *
	 */
	@Test
	public void testReadAndSaveTableDirectly3() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableDirectly3");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：List", ArrayList.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}


		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャH", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_直接表読み込み３.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み３.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 50, 3, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田H", getCellValue(sheet, 53, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄H", getCellValue(sheet, 54, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 3, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 59, 3, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 52, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 62, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 63, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 64, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 65, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 62, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 63, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 64, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 65, 3, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 50, 4, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田H", getCellValue(sheet, 53, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長H", getCellValue(sheet, 54, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 60, 4, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 59, 4, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 52, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 62, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 63, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 64, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 65, 4, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 50, 5, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川H", getCellValue(sheet, 53, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康H", getCellValue(sheet, 54, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 5, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 59, 5, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 52, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 62, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 63, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 64, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 65, 5, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 50, 6, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川H", getCellValue(sheet, 53, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャH", getCellValue(sheet, 54, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 59, 6, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 52, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 62, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 63, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 64, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 65, 6, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義による表の直接的な読み書きのテスト
	 * 横方向にレコードが繰り返されるケース
	 * 配列による取得
	 *
	 */
	@Test
	public void testReadAndSaveTableDirectly4() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableDirectly4");
		XMLTestElement[] arrElm = (XMLTestElement[]) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：Array", XMLTestElement[].class, arrElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 2, arrElm.length);

		XMLTestElement elm = arrElm[0];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "篠原H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "まつH", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 156.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"90", "56", "81", "23"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = arrElm[1];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "平H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "清盛H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 168.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"112", "186", "78", "140"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_直接表読み込み４.xls",
				arrElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み４.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 70, 4, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "篠原H", getCellValue(sheet, 73, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "まつH", getCellValue(sheet, 74, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 71, 4, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 156.0, (Double)getCellValue(sheet, 80, 4, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", getCellValue(sheet, 72, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 82, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 83, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 84, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 85, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","90", getCellValue(sheet, 82, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","56", getCellValue(sheet, 83, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","81", getCellValue(sheet, 84, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","23", getCellValue(sheet, 85, 4, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 70, 5, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "平H", getCellValue(sheet, 73, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "清盛H", getCellValue(sheet, 74, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 71, 5, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 168.5, (Double)getCellValue(sheet, 80, 5, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", getCellValue(sheet, 72, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","112", getCellValue(sheet, 82, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","186", getCellValue(sheet, 83, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","78", getCellValue(sheet, 84, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","140", getCellValue(sheet, 85, 5, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義による表（マップ）の直接的な読み書きのテスト
	 * 横方向にレコードが繰り返されるケース
	 *
	 */
	@Test
	public void testReadAndSaveTableDirectlyMappedCell() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableDirectlyMappedCell");
		@SuppressWarnings("unchecked")
		Map<String, String> mappedCell = (Map<String, String>) bridge.load("./files/upload/ParserTest.xls", "基本");

		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, mappedCell.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, mappedCell.keySet().size());

		String[] keys = new String[]{"キー１", "キー２", "キー３", "キー４"};
		String[] values = new String[]{"値１", "値２", "値３", "値４"};
		int i = 0;
		for (String key : mappedCell.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], mappedCell.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_直接表読み込み（MappedCell）.xls",
				mappedCell);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み（MappedCell）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：MappedCell：key1","キー１", getCellValue(sheet, 41, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","値１",   getCellValue(sheet, 42, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","キー２", getCellValue(sheet, 41, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","値２",   getCellValue(sheet, 42, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","キー３", getCellValue(sheet, 41, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","値３",   getCellValue(sheet, 42, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","キー４", getCellValue(sheet, 41, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","値４",   getCellValue(sheet, 42, 6, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義による表（マップ）の直接的な読み書きのテスト
	 * 縦方向にレコードが繰り返されるケース
	 *
	 */
	@Test
	public void testReadAndSaveTableDirectlyMappedCellVertical() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableDirectlyMappedCellVertical");
		@SuppressWarnings("unchecked")
		Map<String, String> countMembersMap = (Map<String, String>) bridge.load("./files/upload/ParserTest.xls", "Users2");

		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, countMembersMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, countMembersMap.keySet().size());

		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"0", "0", "1", "4"};
		int i = 0;
		for (String key : countMembersMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], countMembersMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"Users2",
				"./files/export/XMLParserTest_直接表読み込み（MappedCell：Horisontal）.xls",
				countMembersMap);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み（MappedCell：Horisontal）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("Users2");

			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 36, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","0",   getCellValue(sheet, 36, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 37, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","0",   getCellValue(sheet, 37, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 38, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","1",   getCellValue(sheet, 38, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 39, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","4",   getCellValue(sheet, 39, 3, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * XML定義によるシート名指定のテスト
	 *
	 */
	@Test
	public void testReadAndSaveSpecifySheetNameAtXML() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveSpecifySheetNameAtXML");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls");
		assertEquals("基本（取得）：VerticalRepeats：List", ArrayList.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_シート名指定.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_シート名指定.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 3, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 3, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 3, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 3, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 3, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 3, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 2, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 2, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 2, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 2, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 3, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 3, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 3, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 3, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 4, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 4, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 4, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 4, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 4, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 4, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 4, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 4, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 4, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 4, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 5, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 5, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 5, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 5, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 5, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 5, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 5, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 5, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 5, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 5, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 6, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 6, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 6, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 6, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 6, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 6, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 6, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 6, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 6, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 6, 16, CELL_TYPE_DATE_STR));

		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 表の位置検索に、位置情報（position）を指定した際の動作テスト
	 *
	 */
	@Test
	public void testReadAndSaveTableSpecifiedByPosition() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableSpecifiedByPosition");
		XMLTestElement[] arrElm = (XMLTestElement[]) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：Array", XMLTestElement[].class, arrElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 2, arrElm.length);

		XMLTestElement elm = arrElm[0];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "篠原H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "まつH", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 156.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"90", "56", "81", "23"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = arrElm[1];
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "平H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "清盛H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 168.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"112", "186", "78", "140"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"Users2",
				"./files/export/XMLParserTest_表位置指定読み込み.xls",
				arrElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_表位置指定読み込み.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("Users2");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 70, 4, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "篠原H", getCellValue(sheet, 73, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "まつH", getCellValue(sheet, 74, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 71, 4, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 156.0, (Double)getCellValue(sheet, 80, 4, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月15日", getCellValue(sheet, 72, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 82, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 83, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 84, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 85, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","90", getCellValue(sheet, 82, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","56", getCellValue(sheet, 83, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","81", getCellValue(sheet, 84, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","23", getCellValue(sheet, 85, 4, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 70, 5, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "平H", getCellValue(sheet, 73, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "清盛H", getCellValue(sheet, 74, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 71, 5, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 168.5, (Double)getCellValue(sheet, 80, 5, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月17日", getCellValue(sheet, 72, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","112", getCellValue(sheet, 82, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","186", getCellValue(sheet, 83, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","78", getCellValue(sheet, 84, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","140", getCellValue(sheet, 85, 5, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 表の読み込みに終端文字列（terminate）指定を行わない場合の動作テスト
	 *
	 */
	@Test
	public void testReadAndSaveTableNoSpacifiedTerminate() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableNoSpacifiedTerminate");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");

		assertEquals("基本（取得）：VerticalRepeats：List", ArrayList.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 6, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(4);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 5, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "源", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "静", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 155.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"400", "270", "240", "200"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(5);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 6, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "北条", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "政子", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 158.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月19日", elm.getAdmissionDay());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"184", "197", "182", "178"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/AnnotationParserTest_直接表読み込み１.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/AnnotationParserTest_直接表読み込み１.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 91, 1, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 91, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 91, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 91, 8, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 91, 10, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 91, 9, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 90, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 90, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 90, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 90, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 91, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 91, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 91, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 91, 15, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 92, 1, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 92, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 92, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 92, 8, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 92, 10, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 92, 9, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 92, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 92, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 92, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 92, 15, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 93, 1, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 93, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 93, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 93, 8, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 93, 10, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 93, 9, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 93, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 93, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 93, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 93, 15, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 94, 1, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 94, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 94, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 94, 8, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 94, 10, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 94, 9, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 94, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 94, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 94, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 94, 15, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 5, getCellValue(sheet, 95, 1, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "源", getCellValue(sheet, 95, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "静", getCellValue(sheet, 95, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 95, 8, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 155.5, (Double)getCellValue(sheet, 95, 10, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 95, 9, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","400", getCellValue(sheet, 95, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","270", getCellValue(sheet, 95, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","240", getCellValue(sheet, 95, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","200", getCellValue(sheet, 95, 15, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 6, getCellValue(sheet, 96, 1, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "北条", getCellValue(sheet, 96, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "政子", getCellValue(sheet, 96, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 96, 8, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 158.0, (Double)getCellValue(sheet, 96, 10, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月19日", getCellValue(sheet, 96, 9, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","184", getCellValue(sheet, 96, 12, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","197", getCellValue(sheet, 96, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","182", getCellValue(sheet, 96, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","178", getCellValue(sheet, 96, 15, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 表の読み込みに必須指定（use=required）を指定した際の動作テスト
	 * 必須だが該当する表が見つからない場合⇒例外があがる
	 */
	@SuppressWarnings("unchecked")
	@Test(expected=CellNotFoundException.class)
	public void testReadAndSaveTableUseRequired() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableUseRequired");
		@SuppressWarnings("unused")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
	}

	/**
	 * 表の読み込みに任意指定（use=optional）を指定した際の動作テスト
	 * 該当する表が見つからない場合⇒空の指定されたリストを返す
	 */
	@Test
	public void testReadAndSaveTableUseOptional() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableUseOptional");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");

		assertEquals("基本（取得）：VerticalRepeats：List", Vector.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 0, listElm.size());

	}

	/**
	 * 表の読み込みに必須 / 任意の指定を行わなかった際の動作テスト
	 * 該当する表が見つからない場合⇒use=optionalと同じ動作（空の指定されたリストを返す）
	 */
	@Test
	public void testReadAndSaveTableUseNone() throws ExcelPOJOException, IOException {
		ExcelPOJOBridge bridge = new ExcelPOJOBridge(AnnotationTestElementReadTableUseNone.class);
		@SuppressWarnings("unchecked")
		List<AnnotationTestElementReadTableUseNone> listElm = (List<AnnotationTestElementReadTableUseNone>) bridge.load("./files/upload/ParserTest.xls", "基本");

		assertEquals("基本（取得）：VerticalRepeats：List", Vector.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 0, listElm.size());

	}

	/**
	 * ラベルによる位置検索に対し、データ取得位置（retrieveFrom=right）の動作テスト
	 *
	 */
	@Test
	public void testReadAndSaveLabeledCellRetrieveFromRight() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveLabeledCellRetrieveFromRight");
		XMLTest targetBean = (XMLTest) bridge.load("./files/upload/ParserTest.xls", "ラベル読み込み位置");

		assertEquals("基本（取得）：LabeledCell：String", "右のデータ", targetBean.getStringField4LabeledCell1());

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"ラベル読み込み位置",
				"./files/export/XMLParserTest_ラベル読み込み位置（右）.xls",
				targetBean);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_ラベル読み込み位置（右）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("ラベル読み込み位置");

			assertEquals("基本（書き込み）：LabeledCell：String", "右のデータ", getCellValue(sheet, 4, 4, CELL_TYPE_STRING));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * ラベルによる位置検索に対し、データ取得位置（retrieveFrom=down）の動作テスト
	 *
	 */
	@Test
	public void testReadAndSaveLabeledCellRetrieveFromBottom() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveLabeledCellRetrieveFromBottom");
		XMLTest targetBean = (XMLTest) bridge.load("./files/upload/ParserTest.xls", "ラベル読み込み位置");

		assertEquals("基本（取得）：LabeledCell：String", "下のデータ", targetBean.getStringField4LabeledCell1());

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"ラベル読み込み位置",
				"./files/export/XMLParserTest_ラベル読み込み位置（下）.xls",
				targetBean);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_ラベル読み込み位置（下）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("ラベル読み込み位置");

			assertEquals("基本（書き込み）：LabeledCell：String", "下のデータ", getCellValue(sheet, 5, 3, CELL_TYPE_STRING));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * ラベルによる位置検索に対し、データ取得位置（retrieveFrom=left）の動作テスト
	 *
	 */
	@Test
	public void testReadAndSaveLabeledCellRetrieveFromLeft() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveLabeledCellRetrieveFromLeft");
		XMLTest targetBean = (XMLTest) bridge.load("./files/upload/ParserTest.xls", "ラベル読み込み位置");

		assertEquals("基本（取得）：LabeledCell：String", "左のデータ", targetBean.getStringField4LabeledCell1());

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"ラベル読み込み位置",
				"./files/export/XMLParserTest_ラベル読み込み位置（左）.xls",
				targetBean);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_ラベル読み込み位置（左）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("ラベル読み込み位置");

			assertEquals("基本（書き込み）：LabeledCell：String", "左のデータ", getCellValue(sheet, 4, 2, CELL_TYPE_STRING));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 結合されたラベルによるデータ取得（margedLabel）の動作テスト
	 *
	 */
	@Test
	public void testReadAndSaveLabeledCellMargedLabel() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveLabeledCellMargedLabel");
		XMLTest targetBean = (XMLTest) bridge.load("./files/upload/ParserTest.xls", "Users2");

		assertEquals("基本（取得）：LabeledCell：String", "会員リスト", targetBean.getStringField4LabeledCell1());
		assertEquals("基本（取得）：LabeledCell：String", "ExcelPOJOの会員", targetBean.getStringField4PointedCell1());
		assertEquals("基本（取得）：LabeledCell：String", "会員リスト（２）", targetBean.getStringField4ConstantValue1());

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"Users2",
				"./files/export/XMLParserTest_ラベル連結.xls",
				targetBean);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_ラベル連結.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("Users2");

			assertEquals("基本（書き込み）：LabeledCell：String", "会員リスト", getCellValue(sheet, 1, 2, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：LabeledCell：String", "ExcelPOJOの会員", getCellValue(sheet, 2, 2, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：LabeledCell：String", "会員リスト（２）", getCellValue(sheet, 1, 5, CELL_TYPE_STRING));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 値の省略に対する読み書きのテスト
	 * 表全体に指定（縦の表）のケース
	 *
	 */
	@Test
	public void testReadAndSaveTableMargedRowsSpacifiedByVerticalRepeats() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableMargedRowsSpacifiedByVerticalRepeats");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：List", Vector.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "女性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_値の省略（項目）.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_値の省略（項目）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 3, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 3, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 3, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 3, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 3, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 3, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 3, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 2, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 2, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 2, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 2, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 3, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 3, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 3, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 3, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 4, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 4, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 4, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 4, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 4, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 4, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 4, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 4, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 4, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 4, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 4, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 5, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 5, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 5, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 5, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 5, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 5, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 5, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 5, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 5, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 5, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 5, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 6, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 6, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 6, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 6, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 6, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 6, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "女性", getCellValue(sheet, 6, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 6, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 6, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 6, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 6, 16, CELL_TYPE_DATE_STR));

		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 値の省略に対する読み書きのテスト
	 * 表全体に指定（縦の表）のケース
	 *
	 */
	@Test
	public void testReadAndSaveTableMargedRowsSpacifiedByHorizontalRepeats() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableMargedRowsSpacifiedByHorizontalRepeats");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：List", ArrayList.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康H", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}


		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川H", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャH", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "女性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_直接表読み込み３.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_直接表読み込み３.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 50, 3, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田H", getCellValue(sheet, 53, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄H", getCellValue(sheet, 54, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 3, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 59, 3, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 52, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 58, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 62, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 63, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 64, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 65, 2, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 62, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 63, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 64, 3, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 65, 3, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 50, 4, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田H", getCellValue(sheet, 53, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長H", getCellValue(sheet, 54, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 60, 4, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 59, 4, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 52, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 58, 4, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 62, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 63, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 64, 4, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 65, 4, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 50, 5, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川H", getCellValue(sheet, 53, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康H", getCellValue(sheet, 54, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 5, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 59, 5, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 52, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 58, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 62, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 63, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 64, 5, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 65, 5, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 50, 6, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川H", getCellValue(sheet, 53, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャH", getCellValue(sheet, 54, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 60, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 59, 6, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 52, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "女性", getCellValue(sheet, 58, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 62, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 63, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 64, 6, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 65, 6, CELL_TYPE_DATE_STR));
		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 値の省略に対する読み書きのテスト
	 * ラベルごとに指定のケース
	 *
	 */
	@Test
	public void testReadAndSaveTableMargedRowsSpacifiedByLabel() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableMargedRowsSpacifiedByLabel");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：List", Vector.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "女性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_値の省略（項目）.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_値の省略（項目）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 3, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 3, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 3, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 3, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 3, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 3, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 3, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 2, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 2, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 2, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 2, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 3, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 3, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 3, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 3, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 4, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 4, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 4, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 4, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 4, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 4, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 4, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 4, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 4, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 4, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 4, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 5, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 5, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 5, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 5, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 5, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 5, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 5, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 5, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 5, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 5, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 5, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 6, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 6, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 6, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 6, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 6, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 6, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "女性", getCellValue(sheet, 6, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 6, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 6, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 6, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 6, 16, CELL_TYPE_DATE_STR));

		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * 値の省略に対する読み書きのテスト
	 * 指定なしのケース 空欄は空欄のまま
	 *
	 */
	@Test
	public void testReadAndSaveTableMargedRowsSpacifiedNone() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveTableMargedRowsSpacifiedNone");
		@SuppressWarnings("unchecked")
		List<XMLTestElement> listElm = (List<XMLTestElement>) bridge.load("./files/upload/ParserTest.xls", "基本");
		assertEquals("基本（取得）：VerticalRepeats：List", Vector.class, listElm.getClass());
		assertEquals("基本（取得）：VerticalRepeats：size()", 4, listElm.size());

		XMLTestElement elm = listElm.get(0);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 1, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "武田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信玄", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 175.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "男性", elm.getGender());
		Map<String, String> useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		String[] keys = new String[]{"5月", "6月", "7月", "8月"};
		String[] values = new String[]{"160", "182", "165", "177"};
		int i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 2, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "織田", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "信長", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", true, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 178.5, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"193", "188", "171", "165"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(2);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 3, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "徳川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "家康", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 165.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"162", "155", "165", "166"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		elm = listElm.get(3);
		assertEquals("基本（取得）：VerticalRepeats(Element)：int", 4, elm.getId());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "細川", elm.getFirstName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "ガラシャ", elm.getLastName());
		assertEquals("基本（取得）：VerticalRepeats(Element)：boolean", false, elm.isPremiumMember());
		assertEquals("基本（取得）：VerticalRepeats(Element)：double", 160.0, elm.getTall(), 0.1);
		assertEquals("基本（取得）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", elm.getAdmissionDay());
		assertEquals("基本（取得）：VerticalRepeats(Element)：String", "女性", elm.getGender());
		useTimeMap = elm.getUseTimeMap();
		assertEquals("基本（取得）：MappedCell：LinkedHashMap", LinkedHashMap.class, useTimeMap.getClass());
		assertEquals("基本（取得）：MappedCell：size()", 4, useTimeMap.keySet().size());
		keys = new String[]{"5月", "6月", "7月", "8月"};
		values = new String[]{"143", "177", "151", "182"};
		i = 0;
		for (String key : useTimeMap.keySet()) {
			assertEquals("基本（取得）：MappedCell：key" + i, keys[i], key);
			assertEquals("基本（取得）：MappedCell：value" + i, values[i], useTimeMap.get(key));
			i++;
		}

		bridge.save(
				"./files/template/ParserTest_Template.xls",
				"基本",
				"./files/export/XMLParserTest_値の省略（項目）.xls",
				listElm);

		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("./files/export/XMLParserTest_値の省略（項目）.xls");
			HSSFWorkbook workBook = new HSSFWorkbook(new POIFSFileSystem(fileInputStream));
			HSSFSheet sheet = workBook.getSheet("基本");

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 1, getCellValue(sheet, 3, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "武田", getCellValue(sheet, 3, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信玄", getCellValue(sheet, 3, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 3, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 175.5, (Double)getCellValue(sheet, 3, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月11日", getCellValue(sheet, 3, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "男性", getCellValue(sheet, 3, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：key1","5月", getCellValue(sheet, 2, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key2","6月", getCellValue(sheet, 2, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key3","7月", getCellValue(sheet, 2, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：key4","8月", getCellValue(sheet, 2, 16, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val1","160", getCellValue(sheet, 3, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","182", getCellValue(sheet, 3, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 3, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","177", getCellValue(sheet, 3, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 2, getCellValue(sheet, 4, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "織田", getCellValue(sheet, 4, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "信長", getCellValue(sheet, 4, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", true, getCellValue(sheet, 4, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 178.5, (Double)getCellValue(sheet, 4, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月20日", getCellValue(sheet, 4, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "", getCellValue(sheet, 4, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","193", getCellValue(sheet, 4, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","188", getCellValue(sheet, 4, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","171", getCellValue(sheet, 4, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","165", getCellValue(sheet, 4, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 3, getCellValue(sheet, 5, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "徳川", getCellValue(sheet, 5, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "家康", getCellValue(sheet, 5, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 5, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 165.0, (Double)getCellValue(sheet, 5, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月18日", getCellValue(sheet, 5, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "", getCellValue(sheet, 5, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","162", getCellValue(sheet, 5, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","155", getCellValue(sheet, 5, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","165", getCellValue(sheet, 5, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","166", getCellValue(sheet, 5, 16, CELL_TYPE_DATE_STR));

			assertEquals("基本（書き込み）：VerticalRepeats(Element)：int", 4, getCellValue(sheet, 6, 2, CELL_TYPE_INT));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "細川", getCellValue(sheet, 6, 5, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "ガラシャ", getCellValue(sheet, 6, 6, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：boolean", false, getCellValue(sheet, 6, 9, CELL_TYPE_BOOLEAN));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：double", 160.0, (Double)getCellValue(sheet, 6, 11, CELL_TYPE_DOUBLE), 0.1);
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：日付（文字列）", "2010年6月22日", getCellValue(sheet, 6, 10, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：VerticalRepeats(Element)：String", "女性", getCellValue(sheet, 6, 3, CELL_TYPE_STRING));
			assertEquals("基本（書き込み）：MappedCell：val1","143", getCellValue(sheet, 6, 13, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val2","177", getCellValue(sheet, 6, 14, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val3","151", getCellValue(sheet, 6, 15, CELL_TYPE_DATE_STR));
			assertEquals("基本（書き込み）：MappedCell：val4","182", getCellValue(sheet, 6, 16, CELL_TYPE_DATE_STR));

		} finally {
			try { fileInputStream.close(); } catch (Exception e) { }
		}
	}

	/**
	 * ラベルの読み込みに必須指定（use=required）を指定した際の動作テスト
	 * 必須だが該当する表が見つからない場合⇒例外があがる
	 */
	@Test(expected=CellNotFoundException.class)
	public void testReadAndSaveLabeledCellUseRequired() throws ExcelPOJOException, IOException {
		ApplicationContext context = new ClassPathXmlApplicationContext("./config/XMLTests.xml");
		ExcelPOJOBridge bridge = (ExcelPOJOBridge)context.getBean("testReadAndSaveLabeledCellUseRequired");
		@SuppressWarnings("unused")
		XMLTest targetBean = (XMLTest) bridge.load("./files/upload/ParserTest.xls", "ラベル読み込み位置");
	}
}
