/*******************************************************************************
* Copyright (c) 2007, 2009 Wind River Systems, Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Markus Schorn - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.core.parser.tests.scanner;
import java.io.IOException;
import junit.framework.ComparisonFailure;
import org.eclipse.cdt.core.dom.ast.IASTProblem;
import org.eclipse.cdt.core.dom.ast.IMacroBinding;
import org.eclipse.cdt.core.dom.parser.IScannerExtensionConfiguration;
import org.eclipse.cdt.core.dom.parser.c.GCCScannerExtensionConfiguration;
import org.eclipse.cdt.core.dom.parser.cpp.GPPScannerExtensionConfiguration;
import org.eclipse.cdt.core.parser.EndOfFileException;
import org.eclipse.cdt.core.parser.FileContent;
import org.eclipse.cdt.core.parser.IParserLogService;
import org.eclipse.cdt.core.parser.IScannerInfo;
import org.eclipse.cdt.core.parser.IToken;
import org.eclipse.cdt.core.parser.IncludeFileContentProvider;
import org.eclipse.cdt.core.parser.NullLogService;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.core.parser.ParserMode;
import org.eclipse.cdt.core.parser.ScannerInfo;
import org.eclipse.cdt.core.parser.util.CharArrayUtils;
import org.eclipse.cdt.core.testplugin.CTestPlugin;
import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
import org.eclipse.cdt.core.testplugin.util.TestSourceReader;
import org.eclipse.cdt.internal.core.parser.scanner.CPreprocessor;
import org.eclipse.cdt.internal.core.parser.scanner.ILocationResolver;
public abstract class PreprocessorTestsBase extends BaseTestCase {
private static final IParserLogService NULL_LOG = new NullLogService();
protected CPreprocessor fScanner;
protected ILocationResolver fLocationResolver;
public PreprocessorTestsBase(String name) {
super(name);
}
public PreprocessorTestsBase() {
super();
}
protected void initializeScanner(String input) throws IOException {
initializeScanner(input, ParserMode.COMPLETE_PARSE);
}
protected void initializeScanner(String input, ParserMode mode) throws IOException {
initializeScanner(getContent(input), ParserLanguage.CPP, mode, new ScannerInfo());
}
protected void initializeScanner(String input, ParserLanguage lang) throws IOException {
initializeScanner(getContent(input), lang, ParserMode.COMPLETE_PARSE, new ScannerInfo());
}
protected void initializeScanner(String input, ParserLanguage lang, IScannerExtensionConfiguration scannerConfig) throws IOException {
initializeScanner(getContent(input), lang, ParserMode.COMPLETE_PARSE, new ScannerInfo(), scannerConfig);
}
private FileContent getContent(String input) {
return FileContent.create("<test-code>", input.toCharArray());
}
protected void initializeScanner(FileContent input, ParserLanguage lang, ParserMode mode, IScannerInfo scannerInfo) throws IOException {
initializeScanner(input, lang, mode, scannerInfo, null);
}
protected void initializeScanner(FileContent input, ParserLanguage lang, ParserMode mode, IScannerInfo scannerInfo, IScannerExtensionConfiguration scannerConfig) throws IOException {
IncludeFileContentProvider readerFactory= FileCodeReaderFactory.getInstance();
//IScannerExtensionConfiguration scannerConfig;
if(scannerConfig == null) {
if (lang == ParserLanguage.C) {
scannerConfig= GCCScannerExtensionConfiguration.getInstance();
}
else {
scannerConfig= GPPScannerExtensionConfiguration.getInstance(scannerInfo);
}
}
fScanner= new CPreprocessor(input, scannerInfo, lang, NULL_LOG, scannerConfig, readerFactory);
fLocationResolver= fScanner.getLocationMap();
}
protected void initializeScanner() throws Exception {
initializeScanner(getAboveComment());
}
protected StringBuilder[] getTestContent(int sections) throws IOException {
return TestSourceReader.getContentsForTest(
CTestPlugin.getDefault().getBundle(), "parser", getClass(), getName(), sections);
}
protected String getAboveComment() throws IOException {
return getTestContent(1)[0].toString();
}
protected void fullyTokenize() throws Exception {
try {
for(;;) {
IToken t= fScanner.nextToken();
}
} catch ( EndOfFileException e){
}
}
protected void validateToken(int tokenType) throws Exception {
IToken t= fScanner.nextToken();
assertEquals(tokenType, t.getType());
}
protected void validateToken(int tokenType, String image) throws Exception {
try {
IToken t= fScanner.nextToken();
assertEquals(tokenType, t.getType());
assertEquals(image, t.getImage());
} catch (EndOfFileException e) {
fail("Missing token " + image);
}
}
protected void validateInteger(String expectedImage) throws Exception {
validateToken(IToken.tINTEGER, expectedImage);
}
protected void validateIdentifier(String expectedImage) throws Exception {
validateToken(IToken.tIDENTIFIER, expectedImage);
}
protected void validateString(String expectedImage) throws Exception {
validateToken(IToken.tSTRING, "\"" + expectedImage + "\"");
}
protected void validateLString(String expectedImage) throws Exception {
validateToken(IToken.tLSTRING, "L\"" + expectedImage + "\"");
}
protected void validateUTF16String(String expectedImage) throws Exception {
validateToken(IToken.tUTF16STRING, "u\"" + expectedImage + "\"");
}
protected void validateUTF32String(String expectedImage) throws Exception {
validateToken(IToken.tUTF32STRING, "U\"" + expectedImage + "\"");
}
protected void validateChar(String expectedImage) throws Exception {
validateToken(IToken.tCHAR, "'" + expectedImage + "'");
}
protected void validateWideChar(String expectedImage) throws Exception {
validateToken(IToken.tLCHAR, "L'" + expectedImage + "'");
}
protected void validateUTF16Char(String expectedImage) throws Exception {
validateToken(IToken.tUTF16CHAR, "u'" + expectedImage + "'");
}
protected void validateUTF32Char(String expectedImage) throws Exception {
validateToken(IToken.tUTF32CHAR, "U'" + expectedImage + "'");
}
protected void validateFloatingPointLiteral(String expectedImage) throws Exception {
validateToken(IToken.tFLOATINGPT, expectedImage);
}
protected void validateEOF() throws Exception {
try {
IToken t= fScanner.nextToken();
fail("superfluous token " + t);
}
catch(EndOfFileException e) {
}
}
private void assertCharArrayEquals(char[] expected, char[] actual) {
if (!CharArrayUtils.equals(expected, actual))
throw new ComparisonFailure(null, new String(expected), new String(actual));
}
protected void validateDefinition(String name, String value) {
IMacroBinding expObject = fScanner.getMacroDefinitions().get(name);
assertNotNull(expObject);
assertCharArrayEquals(value.toCharArray(), expObject.getExpansion());
}
protected void validateDefinition(String name, int value) {
validateDefinition(name, String.valueOf(value));
}
protected void validateAsUndefined(String name) {
assertNull(fScanner.getMacroDefinitions().get(name.toCharArray()));
}
protected void validateProblemCount(int count) throws Exception {
assertEquals(count, fLocationResolver.getScannerProblems().length);
}
protected void validateProblem(int idx, int problemID, String detail) throws Exception {
IASTProblem problem= fLocationResolver.getScannerProblems()[idx];
assertEquals(problemID, problem.getID());
if (detail != null) {
assertEquals(detail, problem.getArguments()[0]);
}
}
}