/*
* Copyright (C) 2007, Dave Watson <dwatson@mimvista.com>
* Copyright (C) 2009-2010, Google Inc.
* Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
* Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
* Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
* Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.lib;
import static java.util.concurrent.TimeUnit.DAYS;
import static java.util.concurrent.TimeUnit.HOURS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.MINUTES;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.eclipse.jgit.api.MergeCommand.FastForwardMode;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.junit.MockSystemReader;
import org.eclipse.jgit.merge.MergeConfig;
import org.eclipse.jgit.storage.file.FileBasedConfig;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.SystemReader;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
/**
* Test reading of git config
*/
public class ConfigTest {
@Rule
public ExpectedException expectedEx = ExpectedException.none();
@Rule
public TemporaryFolder tmp = new TemporaryFolder();
@After
public void tearDown() {
SystemReader.setInstance(null);
}
@Test
public void test001_ReadBareKey() throws ConfigInvalidException {
final Config c = parse("[foo]\nbar\n");
assertTrue(c.getBoolean("foo", null, "bar", false));
assertEquals("", c.getString("foo", null, "bar"));
}
@Test
public void test002_ReadWithSubsection() throws ConfigInvalidException {
final Config c = parse("[foo \"zip\"]\nbar\n[foo \"zap\"]\nbar=false\nn=3\n");
assertTrue(c.getBoolean("foo", "zip", "bar", false));
assertEquals("", c.getString("foo","zip", "bar"));
assertFalse(c.getBoolean("foo", "zap", "bar", true));
assertEquals("false", c.getString("foo", "zap", "bar"));
assertEquals(3, c.getInt("foo", "zap", "n", 4));
assertEquals(4, c.getInt("foo", "zap","m", 4));
}
@Test
public void test003_PutRemote() {
final Config c = new Config();
c.setString("sec", "ext", "name", "value");
c.setString("sec", "ext", "name2", "value2");
final String expText = "[sec \"ext\"]\n\tname = value\n\tname2 = value2\n";
assertEquals(expText, c.toText());
}
@Test
public void test004_PutGetSimple() {
Config c = new Config();
c.setString("my", null, "somename", "false");
assertEquals("false", c.getString("my", null, "somename"));
assertEquals("[my]\n\tsomename = false\n", c.toText());
}
@Test
public void test005_PutGetStringList() {
Config c = new Config();
final LinkedList<String> values = new LinkedList<String>();
values.add("value1");
values.add("value2");
c.setStringList("my", null, "somename", values);
final Object[] expArr = values.toArray();
final String[] actArr = c.getStringList("my", null, "somename");
assertArrayEquals(expArr, actArr);
final String expText = "[my]\n\tsomename = value1\n\tsomename = value2\n";
assertEquals(expText, c.toText());
}
@Test
public void test006_readCaseInsensitive() throws ConfigInvalidException {
final Config c = parse("[Foo]\nBar\n");
assertTrue(c.getBoolean("foo", null, "bar", false));
assertEquals("", c.getString("foo", null, "bar"));
}
@Test
public void test007_readUserConfig() {
final MockSystemReader mockSystemReader = new MockSystemReader();
SystemReader.setInstance(mockSystemReader);
final String hostname = mockSystemReader.getHostname();
final Config userGitConfig = mockSystemReader.openUserConfig(null,
FS.DETECTED);
final Config localConfig = new Config(userGitConfig);
mockSystemReader.clearProperties();
String authorName;
String authorEmail;
// no values defined nowhere
authorName = localConfig.get(UserConfig.KEY).getAuthorName();
authorEmail = localConfig.get(UserConfig.KEY).getAuthorEmail();
assertEquals(Constants.UNKNOWN_USER_DEFAULT, authorName);
assertEquals(Constants.UNKNOWN_USER_DEFAULT + "@" + hostname, authorEmail);
assertTrue(localConfig.get(UserConfig.KEY).isAuthorNameImplicit());
assertTrue(localConfig.get(UserConfig.KEY).isAuthorEmailImplicit());
// the system user name is defined
mockSystemReader.setProperty(Constants.OS_USER_NAME_KEY, "os user name");
localConfig.uncache(UserConfig.KEY);
authorName = localConfig.get(UserConfig.KEY).getAuthorName();
assertEquals("os user name", authorName);
assertTrue(localConfig.get(UserConfig.KEY).isAuthorNameImplicit());
if (hostname != null && hostname.length() != 0) {
authorEmail = localConfig.get(UserConfig.KEY).getAuthorEmail();
assertEquals("os user name@" + hostname, authorEmail);
}
assertTrue(localConfig.get(UserConfig.KEY).isAuthorEmailImplicit());
// the git environment variables are defined
mockSystemReader.setProperty(Constants.GIT_AUTHOR_NAME_KEY, "git author name");
mockSystemReader.setProperty(Constants.GIT_AUTHOR_EMAIL_KEY, "author@email");
localConfig.uncache(UserConfig.KEY);
authorName = localConfig.get(UserConfig.KEY).getAuthorName();
authorEmail = localConfig.get(UserConfig.KEY).getAuthorEmail();
assertEquals("git author name", authorName);
assertEquals("author@email", authorEmail);
assertFalse(localConfig.get(UserConfig.KEY).isAuthorNameImplicit());
assertFalse(localConfig.get(UserConfig.KEY).isAuthorEmailImplicit());
// the values are defined in the global configuration
// first clear environment variables since they would override
// configuration files
mockSystemReader.clearProperties();
userGitConfig.setString("user", null, "name", "global username");
userGitConfig.setString("user", null, "email", "author@globalemail");
authorName = localConfig.get(UserConfig.KEY).getAuthorName();
authorEmail = localConfig.get(UserConfig.KEY).getAuthorEmail();
assertEquals("global username", authorName);
assertEquals("author@globalemail", authorEmail);
assertFalse(localConfig.get(UserConfig.KEY).isAuthorNameImplicit());
assertFalse(localConfig.get(UserConfig.KEY).isAuthorEmailImplicit());
// the values are defined in the local configuration
localConfig.setString("user", null, "name", "local username");
localConfig.setString("user", null, "email", "author@localemail");
authorName = localConfig.get(UserConfig.KEY).getAuthorName();
authorEmail = localConfig.get(UserConfig.KEY).getAuthorEmail();
assertEquals("local username", authorName);
assertEquals("author@localemail", authorEmail);
assertFalse(localConfig.get(UserConfig.KEY).isAuthorNameImplicit());
assertFalse(localConfig.get(UserConfig.KEY).isAuthorEmailImplicit());
authorName = localConfig.get(UserConfig.KEY).getCommitterName();
authorEmail = localConfig.get(UserConfig.KEY).getCommitterEmail();
assertEquals("local username", authorName);
assertEquals("author@localemail", authorEmail);
assertFalse(localConfig.get(UserConfig.KEY).isCommitterNameImplicit());
assertFalse(localConfig.get(UserConfig.KEY).isCommitterEmailImplicit());
// also git environment variables are defined
mockSystemReader.setProperty(Constants.GIT_AUTHOR_NAME_KEY,
"git author name");
mockSystemReader.setProperty(Constants.GIT_AUTHOR_EMAIL_KEY,
"author@email");
localConfig.setString("user", null, "name", "local username");
localConfig.setString("user", null, "email", "author@localemail");
authorName = localConfig.get(UserConfig.KEY).getAuthorName();
authorEmail = localConfig.get(UserConfig.KEY).getAuthorEmail();
assertEquals("git author name", authorName);
assertEquals("author@email", authorEmail);
assertFalse(localConfig.get(UserConfig.KEY).isAuthorNameImplicit());
assertFalse(localConfig.get(UserConfig.KEY).isAuthorEmailImplicit());
}
@Test
public void testReadUserConfigWithInvalidCharactersStripped() {
final MockSystemReader mockSystemReader = new MockSystemReader();
final Config localConfig = new Config(mockSystemReader.openUserConfig(
null, FS.DETECTED));
localConfig.setString("user", null, "name", "foo<bar");
localConfig.setString("user", null, "email", "baz>\nqux@example.com");
UserConfig userConfig = localConfig.get(UserConfig.KEY);
assertEquals("foobar", userConfig.getAuthorName());
assertEquals("bazqux@example.com", userConfig.getAuthorEmail());
}
@Test
public void testReadBoolean_TrueFalse1() throws ConfigInvalidException {
final Config c = parse("[s]\na = true\nb = false\n");
assertEquals("true", c.getString("s", null, "a"));
assertEquals("false", c.getString("s", null, "b"));
assertTrue(c.getBoolean("s", "a", false));
assertFalse(c.getBoolean("s", "b", true));
}
@Test
public void testReadBoolean_TrueFalse2() throws ConfigInvalidException {
final Config c = parse("[s]\na = TrUe\nb = fAlSe\n");
assertEquals("TrUe", c.getString("s", null, "a"));
assertEquals("fAlSe", c.getString("s", null, "b"));
assertTrue(c.getBoolean("s", "a", false));
assertFalse(c.getBoolean("s", "b", true));
}
@Test
public void testReadBoolean_YesNo1() throws ConfigInvalidException {
final Config c = parse("[s]\na = yes\nb = no\n");
assertEquals("yes", c.getString("s", null, "a"));
assertEquals("no", c.getString("s", null, "b"));
assertTrue(c.getBoolean("s", "a", false));
assertFalse(c.getBoolean("s", "b", true));
}
@Test
public void testReadBoolean_YesNo2() throws ConfigInvalidException {
final Config c = parse("[s]\na = yEs\nb = NO\n");
assertEquals("yEs", c.getString("s", null, "a"));
assertEquals("NO", c.getString("s", null, "b"));
assertTrue(c.getBoolean("s", "a", false));
assertFalse(c.getBoolean("s", "b", true));
}
@Test
public void testReadBoolean_OnOff1() throws ConfigInvalidException {
final Config c = parse("[s]\na = on\nb = off\n");
assertEquals("on", c.getString("s", null, "a"));
assertEquals("off", c.getString("s", null, "b"));
assertTrue(c.getBoolean("s", "a", false));
assertFalse(c.getBoolean("s", "b", true));
}
@Test
public void testReadBoolean_OnOff2() throws ConfigInvalidException {
final Config c = parse("[s]\na = ON\nb = OFF\n");
assertEquals("ON", c.getString("s", null, "a"));
assertEquals("OFF", c.getString("s", null, "b"));
assertTrue(c.getBoolean("s", "a", false));
assertFalse(c.getBoolean("s", "b", true));
}
static enum TestEnum {
ONE_TWO;
}
@Test
public void testGetEnum() throws ConfigInvalidException {
Config c = parse("[s]\na = ON\nb = input\nc = true\nd = off\n");
assertSame(CoreConfig.AutoCRLF.TRUE, c.getEnum("s", null, "a",
CoreConfig.AutoCRLF.FALSE));
assertSame(CoreConfig.AutoCRLF.INPUT, c.getEnum("s", null, "b",
CoreConfig.AutoCRLF.FALSE));
assertSame(CoreConfig.AutoCRLF.TRUE, c.getEnum("s", null, "c",
CoreConfig.AutoCRLF.FALSE));
assertSame(CoreConfig.AutoCRLF.FALSE, c.getEnum("s", null, "d",
CoreConfig.AutoCRLF.TRUE));
c = new Config();
assertSame(CoreConfig.AutoCRLF.FALSE, c.getEnum("s", null, "d",
CoreConfig.AutoCRLF.FALSE));
c = parse("[s \"b\"]\n\tc = one two\n");
assertSame(TestEnum.ONE_TWO, c.getEnum("s", "b", "c", TestEnum.ONE_TWO));
c = parse("[s \"b\"]\n\tc = one-two\n");
assertSame(TestEnum.ONE_TWO, c.getEnum("s", "b", "c", TestEnum.ONE_TWO));
}
@Test
public void testGetInvalidEnum() throws ConfigInvalidException {
Config c = parse("[a]\n\tb = invalid\n");
try {
c.getEnum("a", null, "b", TestEnum.ONE_TWO);
fail();
} catch (IllegalArgumentException e) {
assertEquals("Invalid value: a.b=invalid", e.getMessage());
}
c = parse("[a \"b\"]\n\tc = invalid\n");
try {
c.getEnum("a", "b", "c", TestEnum.ONE_TWO);
fail();
} catch (IllegalArgumentException e) {
assertEquals("Invalid value: a.b.c=invalid", e.getMessage());
}
}
@Test
public void testSetEnum() {
final Config c = new Config();
c.setEnum("s", "b", "c", TestEnum.ONE_TWO);
assertEquals("[s \"b\"]\n\tc = one two\n", c.toText());
}
@Test
public void testGetFastForwardMergeoptions() throws ConfigInvalidException {
Config c = new Config(null); // not set
assertSame(FastForwardMode.FF, c.getEnum(
ConfigConstants.CONFIG_BRANCH_SECTION, "side",
ConfigConstants.CONFIG_KEY_MERGEOPTIONS, FastForwardMode.FF));
MergeConfig mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF, mergeConfig.getFastForwardMode());
c = parse("[branch \"side\"]\n\tmergeoptions = --ff-only\n");
assertSame(FastForwardMode.FF_ONLY, c.getEnum(
ConfigConstants.CONFIG_BRANCH_SECTION, "side",
ConfigConstants.CONFIG_KEY_MERGEOPTIONS,
FastForwardMode.FF_ONLY));
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF_ONLY, mergeConfig.getFastForwardMode());
c = parse("[branch \"side\"]\n\tmergeoptions = --ff\n");
assertSame(FastForwardMode.FF, c.getEnum(
ConfigConstants.CONFIG_BRANCH_SECTION, "side",
ConfigConstants.CONFIG_KEY_MERGEOPTIONS, FastForwardMode.FF));
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF, mergeConfig.getFastForwardMode());
c = parse("[branch \"side\"]\n\tmergeoptions = --no-ff\n");
assertSame(FastForwardMode.NO_FF, c.getEnum(
ConfigConstants.CONFIG_BRANCH_SECTION, "side",
ConfigConstants.CONFIG_KEY_MERGEOPTIONS, FastForwardMode.NO_FF));
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.NO_FF, mergeConfig.getFastForwardMode());
}
@Test
public void testSetFastForwardMergeoptions() {
final Config c = new Config();
c.setEnum("branch", "side", "mergeoptions", FastForwardMode.FF);
assertEquals("[branch \"side\"]\n\tmergeoptions = --ff\n", c.toText());
c.setEnum("branch", "side", "mergeoptions", FastForwardMode.FF_ONLY);
assertEquals("[branch \"side\"]\n\tmergeoptions = --ff-only\n",
c.toText());
c.setEnum("branch", "side", "mergeoptions", FastForwardMode.NO_FF);
assertEquals("[branch \"side\"]\n\tmergeoptions = --no-ff\n",
c.toText());
}
@Test
public void testGetFastForwardMerge() throws ConfigInvalidException {
Config c = new Config(null); // not set
assertSame(FastForwardMode.Merge.TRUE, c.getEnum(
ConfigConstants.CONFIG_KEY_MERGE, null,
ConfigConstants.CONFIG_KEY_FF, FastForwardMode.Merge.TRUE));
MergeConfig mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF, mergeConfig.getFastForwardMode());
c = parse("[merge]\n\tff = only\n");
assertSame(FastForwardMode.Merge.ONLY, c.getEnum(
ConfigConstants.CONFIG_KEY_MERGE, null,
ConfigConstants.CONFIG_KEY_FF, FastForwardMode.Merge.ONLY));
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF_ONLY, mergeConfig.getFastForwardMode());
c = parse("[merge]\n\tff = true\n");
assertSame(FastForwardMode.Merge.TRUE, c.getEnum(
ConfigConstants.CONFIG_KEY_MERGE, null,
ConfigConstants.CONFIG_KEY_FF, FastForwardMode.Merge.TRUE));
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF, mergeConfig.getFastForwardMode());
c = parse("[merge]\n\tff = false\n");
assertSame(FastForwardMode.Merge.FALSE, c.getEnum(
ConfigConstants.CONFIG_KEY_MERGE, null,
ConfigConstants.CONFIG_KEY_FF, FastForwardMode.Merge.FALSE));
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.NO_FF, mergeConfig.getFastForwardMode());
}
@Test
public void testCombinedMergeOptions() throws ConfigInvalidException {
Config c = new Config(null); // not set
MergeConfig mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF, mergeConfig.getFastForwardMode());
assertTrue(mergeConfig.isCommit());
assertFalse(mergeConfig.isSquash());
// branch..mergeoptions should win over merge.ff
c = parse("[merge]\n\tff = false\n"
+ "[branch \"side\"]\n\tmergeoptions = --ff-only\n");
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF_ONLY, mergeConfig.getFastForwardMode());
assertTrue(mergeConfig.isCommit());
assertFalse(mergeConfig.isSquash());
// merge.ff used for ff setting if not set via mergeoptions
c = parse("[merge]\n\tff = only\n"
+ "[branch \"side\"]\n\tmergeoptions = --squash\n");
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF_ONLY, mergeConfig.getFastForwardMode());
assertTrue(mergeConfig.isCommit());
assertTrue(mergeConfig.isSquash());
// mergeoptions wins if it has ff options amongst other options
c = parse("[merge]\n\tff = false\n"
+ "[branch \"side\"]\n\tmergeoptions = --ff-only --no-commit\n");
mergeConfig = c.get(MergeConfig.getParser("side"));
assertSame(FastForwardMode.FF_ONLY, mergeConfig.getFastForwardMode());
assertFalse(mergeConfig.isCommit());
assertFalse(mergeConfig.isSquash());
}
@Test
public void testSetFastForwardMerge() {
final Config c = new Config();
c.setEnum("merge", null, "ff",
FastForwardMode.Merge.valueOf(FastForwardMode.FF));
assertEquals("[merge]\n\tff = true\n", c.toText());
c.setEnum("merge", null, "ff",
FastForwardMode.Merge.valueOf(FastForwardMode.FF_ONLY));
assertEquals("[merge]\n\tff = only\n", c.toText());
c.setEnum("merge", null, "ff",
FastForwardMode.Merge.valueOf(FastForwardMode.NO_FF));
assertEquals("[merge]\n\tff = false\n", c.toText());
}
@Test
public void testReadLong() throws ConfigInvalidException {
assertReadLong(1L);
assertReadLong(-1L);
assertReadLong(Long.MIN_VALUE);
assertReadLong(Long.MAX_VALUE);
assertReadLong(4L * 1024 * 1024 * 1024, "4g");
assertReadLong(3L * 1024 * 1024, "3 m");
assertReadLong(8L * 1024, "8 k");
try {
assertReadLong(-1, "1.5g");
fail("incorrectly accepted 1.5g");
} catch (IllegalArgumentException e) {
assertEquals("Invalid integer value: s.a=1.5g", e.getMessage());
}
}
@Test
public void testBooleanWithNoValue() throws ConfigInvalidException {
Config c = parse("[my]\n\tempty\n");
assertEquals("", c.getString("my", null, "empty"));
assertEquals(1, c.getStringList("my", null, "empty").length);
assertEquals("", c.getStringList("my", null, "empty")[0]);
assertTrue(c.getBoolean("my", "empty", false));
assertEquals("[my]\n\tempty\n", c.toText());
}
@Test
public void testUnsetBranchSection() throws ConfigInvalidException {
Config c = parse("" //
+ "[branch \"keep\"]\n"
+ " merge = master.branch.to.keep.in.the.file\n"
+ "\n"
+ "[branch \"remove\"]\n"
+ " merge = this.will.get.deleted\n"
+ " remote = origin-for-some-long-gone-place\n"
+ "\n"
+ "[core-section-not-to-remove-in-test]\n"
+ " packedGitLimit = 14\n");
c.unsetSection("branch", "does.not.exist");
c.unsetSection("branch", "remove");
assertEquals("" //
+ "[branch \"keep\"]\n"
+ " merge = master.branch.to.keep.in.the.file\n"
+ "\n"
+ "[core-section-not-to-remove-in-test]\n"
+ " packedGitLimit = 14\n", c.toText());
}
@Test
public void testUnsetSingleSection() throws ConfigInvalidException {
Config c = parse("" //
+ "[branch \"keep\"]\n"
+ " merge = master.branch.to.keep.in.the.file\n"
+ "\n"
+ "[single]\n"
+ " merge = this.will.get.deleted\n"
+ " remote = origin-for-some-long-gone-place\n"
+ "\n"
+ "[core-section-not-to-remove-in-test]\n"
+ " packedGitLimit = 14\n");
c.unsetSection("single", null);
assertEquals("" //
+ "[branch \"keep\"]\n"
+ " merge = master.branch.to.keep.in.the.file\n"
+ "\n"
+ "[core-section-not-to-remove-in-test]\n"
+ " packedGitLimit = 14\n", c.toText());
}
@Test
public void test008_readSectionNames() throws ConfigInvalidException {
final Config c = parse("[a]\n [B]\n");
Set<String> sections = c.getSections();
assertTrue("Sections should contain \"a\"", sections.contains("a"));
assertTrue("Sections should contain \"b\"", sections.contains("b"));
}
@Test
public void test009_readNamesInSection() throws ConfigInvalidException {
String configString = "[core]\n" + "repositoryFormatVersion = 0\n"
+ "filemode = false\n" + "logAllRefUpdates = true\n";
final Config c = parse(configString);
Set<String> names = c.getNames("core");
assertEquals("Core section size", 3, names.size());
assertTrue("Core section should contain \"filemode\"", names
.contains("filemode"));
assertTrue("Core section should contain \"repositoryFormatVersion\"",
names.contains("repositoryFormatVersion"));
assertTrue("Core section should contain \"repositoryformatversion\"",
names.contains("repositoryformatversion"));
Iterator<String> itr = names.iterator();
assertEquals("filemode", itr.next());
assertEquals("logAllRefUpdates", itr.next());
assertEquals("repositoryFormatVersion", itr.next());
assertFalse(itr.hasNext());
}
@Test
public void test_ReadNamesInSectionRecursive()
throws ConfigInvalidException {
String baseConfigString = "[core]\n" + "logAllRefUpdates = true\n";
String configString = "[core]\n" + "repositoryFormatVersion = 0\n"
+ "filemode = false\n";
final Config c = parse(configString, parse(baseConfigString));
Set<String> names = c.getNames("core", true);
assertEquals("Core section size", 3, names.size());
assertTrue("Core section should contain \"filemode\"",
names.contains("filemode"));
assertTrue("Core section should contain \"repositoryFormatVersion\"",
names.contains("repositoryFormatVersion"));
assertTrue("Core section should contain \"logAllRefUpdates\"",
names.contains("logAllRefUpdates"));
assertTrue("Core section should contain \"logallrefupdates\"",
names.contains("logallrefupdates"));
Iterator<String> itr = names.iterator();
assertEquals("filemode", itr.next());
assertEquals("repositoryFormatVersion", itr.next());
assertEquals("logAllRefUpdates", itr.next());
assertFalse(itr.hasNext());
}
@Test
public void test010_readNamesInSubSection() throws ConfigInvalidException {
String configString = "[a \"sub1\"]\n"//
+ "x = 0\n" //
+ "y = false\n"//
+ "z = true\n"//
+ "[a \"sub2\"]\n"//
+ "a=0\n"//
+ "b=1\n";
final Config c = parse(configString);
Set<String> names = c.getNames("a", "sub1");
assertEquals("Subsection size", 3, names.size());
assertTrue("Subsection should contain \"x\"", names.contains("x"));
assertTrue("Subsection should contain \"y\"", names.contains("y"));
assertTrue("Subsection should contain \"z\"", names.contains("z"));
names = c.getNames("a", "sub2");
assertEquals("Subsection size", 2, names.size());
assertTrue("Subsection should contain \"a\"", names.contains("a"));
assertTrue("Subsection should contain \"b\"", names.contains("b"));
}
@Test
public void readNamesInSubSectionRecursive() throws ConfigInvalidException {
String baseConfigString = "[a \"sub1\"]\n"//
+ "x = 0\n" //
+ "y = false\n"//
+ "[a \"sub2\"]\n"//
+ "A=0\n";//
String configString = "[a \"sub1\"]\n"//
+ "z = true\n"//
+ "[a \"sub2\"]\n"//
+ "B=1\n";
final Config c = parse(configString, parse(baseConfigString));
Set<String> names = c.getNames("a", "sub1", true);
assertEquals("Subsection size", 3, names.size());
assertTrue("Subsection should contain \"x\"", names.contains("x"));
assertTrue("Subsection should contain \"y\"", names.contains("y"));
assertTrue("Subsection should contain \"z\"", names.contains("z"));
names = c.getNames("a", "sub2", true);
assertEquals("Subsection size", 2, names.size());
assertTrue("Subsection should contain \"A\"", names.contains("A"));
assertTrue("Subsection should contain \"a\"", names.contains("a"));
assertTrue("Subsection should contain \"B\"", names.contains("B"));
}
@Test
public void testQuotingForSubSectionNames() {
String resultPattern = "[testsection \"{0}\"]\n\ttestname = testvalue\n";
String result;
Config config = new Config();
config.setString("testsection", "testsubsection", "testname",
"testvalue");
result = MessageFormat.format(resultPattern, "testsubsection");
assertEquals(result, config.toText());
config.clear();
config.setString("testsection", "#quotable", "testname", "testvalue");
result = MessageFormat.format(resultPattern, "#quotable");
assertEquals(result, config.toText());
config.clear();
config.setString("testsection", "with\"quote", "testname", "testvalue");
result = MessageFormat.format(resultPattern, "with\\\"quote");
assertEquals(result, config.toText());
}
@Test
public void testNoFinalNewline() throws ConfigInvalidException {
Config c = parse("[a]\n"
+ "x = 0\n"
+ "y = 1");
assertEquals("0", c.getString("a", null, "x"));
assertEquals("1", c.getString("a", null, "y"));
}
@Test
public void testExplicitlySetEmptyString() throws Exception {
Config c = new Config();
c.setString("a", null, "x", "0");
c.setString("a", null, "y", "");
assertEquals("0", c.getString("a", null, "x"));
assertEquals(0, c.getInt("a", null, "x", 1));
assertEquals("", c.getString("a", null, "y"));
assertArrayEquals(new String[]{""}, c.getStringList("a", null, "y"));
try {
c.getInt("a", null, "y", 1);
} catch (IllegalArgumentException e) {
assertEquals("Invalid integer value: a.y=", e.getMessage());
}
assertNull(c.getString("a", null, "z"));
assertArrayEquals(new String[]{}, c.getStringList("a", null, "z"));
}
@Test
public void testParsedEmptyString() throws Exception {
Config c = parse("[a]\n"
+ "x = 0\n"
+ "y =\n");
assertEquals("0", c.getString("a", null, "x"));
assertEquals(0, c.getInt("a", null, "x", 1));
assertNull(c.getString("a", null, "y"));
assertArrayEquals(new String[]{null}, c.getStringList("a", null, "y"));
try {
c.getInt("a", null, "y", 1);
} catch (IllegalArgumentException e) {
assertEquals("Invalid integer value: a.y=", e.getMessage());
}
assertNull(c.getString("a", null, "z"));
assertArrayEquals(new String[]{}, c.getStringList("a", null, "z"));
}
@Test
public void testSetStringListWithEmptyValue() throws Exception {
Config c = new Config();
c.setStringList("a", null, "x", Arrays.asList(""));
assertArrayEquals(new String[]{""}, c.getStringList("a", null, "x"));
}
@Test
public void testEmptyValueAtEof() throws Exception {
String text = "[a]\nx =";
Config c = parse(text);
assertNull(c.getString("a", null, "x"));
assertArrayEquals(new String[]{null},
c.getStringList("a", null, "x"));
c = parse(text + "\n");
assertNull(c.getString("a", null, "x"));
assertArrayEquals(new String[]{null},
c.getStringList("a", null, "x"));
}
@Test
public void testReadMultipleValuesForName() throws ConfigInvalidException {
Config c = parse("[foo]\nbar=false\nbar=true\n");
assertTrue(c.getBoolean("foo", "bar", false));
}
@Test
public void testIncludeInvalidName() throws ConfigInvalidException {
expectedEx.expect(ConfigInvalidException.class);
expectedEx.expectMessage(JGitText.get().invalidLineInConfigFile);
parse("[include]\nbar\n");
}
@Test
public void testIncludeNoValue() throws ConfigInvalidException {
expectedEx.expect(ConfigInvalidException.class);
expectedEx.expectMessage(JGitText.get().invalidLineInConfigFile);
parse("[include]\npath\n");
}
@Test
public void testIncludeEmptyValue() throws ConfigInvalidException {
expectedEx.expect(ConfigInvalidException.class);
expectedEx.expectMessage(JGitText.get().invalidLineInConfigFile);
parse("[include]\npath=\n");
}
@Test
public void testIncludeValuePathNotFound() throws ConfigInvalidException {
// we do not expect an exception, included path not found are ignored
String notFound = "/not/found";
Config parsed = parse("[include]\npath=" + notFound + "\n");
assertEquals(1, parsed.getSections().size());
assertEquals(notFound, parsed.getString("include", null, "path"));
}
@Test
public void testIncludeValuePathWithTilde() throws ConfigInvalidException {
// we do not expect an exception, included path not supported are
// ignored
String notSupported = "~/someFile";
Config parsed = parse("[include]\npath=" + notSupported + "\n");
assertEquals(1, parsed.getSections().size());
assertEquals(notSupported, parsed.getString("include", null, "path"));
}
@Test
public void testIncludeValuePathRelative() throws ConfigInvalidException {
// we do not expect an exception, included path not supported are
// ignored
String notSupported = "someRelativeFile";
Config parsed = parse("[include]\npath=" + notSupported + "\n");
assertEquals(1, parsed.getSections().size());
assertEquals(notSupported, parsed.getString("include", null, "path"));
}
@Test
public void testIncludeTooManyRecursions() throws IOException {
File config = tmp.newFile("config");
String include = "[include]\npath=" + config.toPath() + "\n";
Files.write(config.toPath(), include.getBytes());
FileBasedConfig fbConfig = new FileBasedConfig(null, config,
FS.DETECTED);
try {
fbConfig.load();
fail();
} catch (ConfigInvalidException cie) {
assertEquals(JGitText.get().tooManyIncludeRecursions,
cie.getCause().getMessage());
}
}
@Test
public void testInclude() throws IOException, ConfigInvalidException {
File config = tmp.newFile("config");
File more = tmp.newFile("config.more");
File other = tmp.newFile("config.other");
String fooBar = "[foo]\nbar=true\n";
String includeMore = "[include]\npath=" + more.toPath() + "\n";
String includeOther = "path=" + other.toPath() + "\n";
String fooPlus = fooBar + includeMore + includeOther;
Files.write(config.toPath(), fooPlus.getBytes());
String fooMore = "[foo]\nmore=bar\n";
Files.write(more.toPath(), fooMore.getBytes());
String otherMore = "[other]\nmore=bar\n";
Files.write(other.toPath(), otherMore.getBytes());
Config parsed = parse("[include]\npath=" + config.toPath() + "\n");
assertTrue(parsed.getBoolean("foo", "bar", false));
assertEquals("bar", parsed.getString("foo", null, "more"));
assertEquals("bar", parsed.getString("other", null, "more"));
}
private static void assertReadLong(long exp) throws ConfigInvalidException {
assertReadLong(exp, String.valueOf(exp));
}
private static void assertReadLong(long exp, String act)
throws ConfigInvalidException {
final Config c = parse("[s]\na = " + act + "\n");
assertEquals(exp, c.getLong("s", null, "a", 0L));
}
private static Config parse(final String content)
throws ConfigInvalidException {
return parse(content, null);
}
private static Config parse(final String content, Config baseConfig)
throws ConfigInvalidException {
final Config c = new Config(baseConfig);
c.fromText(content);
return c;
}
@Test
public void testTimeUnit() throws ConfigInvalidException {
assertEquals(0, parseTime("0", MILLISECONDS));
assertEquals(2, parseTime("2ms", MILLISECONDS));
assertEquals(200, parseTime("200 milliseconds", MILLISECONDS));
assertEquals(0, parseTime("0s", SECONDS));
assertEquals(2, parseTime("2s", SECONDS));
assertEquals(231, parseTime("231sec", SECONDS));
assertEquals(1, parseTime("1second", SECONDS));
assertEquals(300, parseTime("300 seconds", SECONDS));
assertEquals(2, parseTime("2m", MINUTES));
assertEquals(2, parseTime("2min", MINUTES));
assertEquals(1, parseTime("1 minute", MINUTES));
assertEquals(10, parseTime("10 minutes", MINUTES));
assertEquals(5, parseTime("5h", HOURS));
assertEquals(5, parseTime("5hr", HOURS));
assertEquals(1, parseTime("1hour", HOURS));
assertEquals(48, parseTime("48hours", HOURS));
assertEquals(5, parseTime("5 h", HOURS));
assertEquals(5, parseTime("5 hr", HOURS));
assertEquals(1, parseTime("1 hour", HOURS));
assertEquals(48, parseTime("48 hours", HOURS));
assertEquals(48, parseTime("48 \t \r hours", HOURS));
assertEquals(4, parseTime("4d", DAYS));
assertEquals(1, parseTime("1day", DAYS));
assertEquals(14, parseTime("14days", DAYS));
assertEquals(7, parseTime("1w", DAYS));
assertEquals(7, parseTime("1week", DAYS));
assertEquals(14, parseTime("2w", DAYS));
assertEquals(14, parseTime("2weeks", DAYS));
assertEquals(30, parseTime("1mon", DAYS));
assertEquals(30, parseTime("1month", DAYS));
assertEquals(60, parseTime("2mon", DAYS));
assertEquals(60, parseTime("2months", DAYS));
assertEquals(365, parseTime("1y", DAYS));
assertEquals(365, parseTime("1year", DAYS));
assertEquals(365 * 2, parseTime("2years", DAYS));
}
private long parseTime(String value, TimeUnit unit)
throws ConfigInvalidException {
Config c = parse("[a]\na=" + value + "\n");
return c.getTimeUnit("a", null, "a", 0, unit);
}
@Test
public void testTimeUnitDefaultValue() throws ConfigInvalidException {
// value not present
assertEquals(20, parse("[a]\na=0\n").getTimeUnit("a", null, "b", 20,
MILLISECONDS));
// value is empty
assertEquals(20, parse("[a]\na=\" \"\n").getTimeUnit("a", null, "a", 20,
MILLISECONDS));
// value is not numeric
assertEquals(20, parse("[a]\na=test\n").getTimeUnit("a", null, "a", 20,
MILLISECONDS));
}
@Test
public void testTimeUnitInvalid() throws ConfigInvalidException {
expectedEx.expect(IllegalArgumentException.class);
expectedEx
.expectMessage("Invalid time unit value: a.a=1 monttthhh");
parseTime("1 monttthhh", DAYS);
}
@Test
public void testTimeUnitInvalidWithSection() throws ConfigInvalidException {
Config c = parse("[a \"b\"]\na=1 monttthhh\n");
expectedEx.expect(IllegalArgumentException.class);
expectedEx.expectMessage("Invalid time unit value: a.b.a=1 monttthhh");
c.getTimeUnit("a", "b", "a", 0, DAYS);
}
@Test
public void testTimeUnitNegative() throws ConfigInvalidException {
expectedEx.expect(IllegalArgumentException.class);
parseTime("-1", MILLISECONDS);
}
}