@Ignore
@Test
public void testLegendBaseline() throws Exception {
assertTrue("Folder", map.getLegend().get(0) instanceof Folder);
Folder folder = (Folder) map.getLegend().get(0);
assertSame(
"Reference Resource 0",
map.getLayersInternal().get(0),
((LayerLegendItem) folder.getItems().get(0)).getLayer());
assertSame(
"Reference Resource 1",
map.getLayersInternal().get(1),
((LayerLegendItem) folder.getItems().get(1)).getLayer());
assertSame(
"Reference Resource 2",
map.getLayersInternal().get(2),
((LayerLegendItem) map.getLegend().get(1)).getLayer());
assertSame(
"Reference Resource 3",
map.getLayersInternal().get(3),
((LayerLegendItem) map.getLegend().get(2)).getLayer());
}
public MessagesWrapper search(List<SearchTerm> term) throws MessagingException {
if (!folder.isOpen()) {
folder.open(Folder.READ_ONLY);
}
Message[] messages = folder.search(and(term));
return new MessagesWrapper(logger, Arrays.asList(messages), folder);
}
static FolderIcon fromXml(
int resId, Launcher launcher, ViewGroup group, FolderInfo folderInfo, IconCache iconCache) {
FolderIcon icon = (FolderIcon) LayoutInflater.from(launcher).inflate(resId, group, false);
icon.mFolderName = (BubbleTextView) icon.findViewById(R.id.folder_icon_name);
icon.mFolderName.setText(folderInfo.title);
icon.mPreviewBackground = (ImageView) icon.findViewById(R.id.preview_background);
icon.setTag(folderInfo);
icon.setOnClickListener(launcher);
icon.mInfo = folderInfo;
icon.mLauncher = launcher;
icon.setContentDescription(
String.format(launcher.getString(R.string.folder_name_format), folderInfo.title));
Folder folder = Folder.fromXml(launcher);
folder.setDragController(launcher.getDragController());
folder.setFolderIcon(icon);
folder.bind(folderInfo);
icon.mFolder = folder;
icon.mFolderRingAnimator = new FolderRingAnimator(launcher, icon);
folderInfo.addListener(icon);
return icon;
}
@Test
public void visit() throws Exception {
Folder lorem = manager.getFileFactory().createFolder("parent");
manager.getFileSystem().add(root, lorem);
Folder childA = manager.getFileFactory().createFolder("childA");
manager.getFileSystem().add(lorem, childA);
Folder childB = manager.getFileFactory().createFolder("childB");
manager.getFileSystem().add(lorem, childB);
TextFile t1 = manager.getFileFactory().createTextFile("lorem1.txt", getSampleText());
TextFile t2 = manager.getFileFactory().createTextFile("lorem2.txt", getSampleText());
TextFile t3 = manager.getFileFactory().createTextFile("lorem3.txt", getSampleText());
TextFile t4 = manager.getFileFactory().createTextFile("lorem4.txt", getSampleText());
TextFile t5 = manager.getFileFactory().createTextFile("lorem5.txt", getSampleText());
manager.getFileSystem().add(lorem, t1);
manager.getFileSystem().add(childA, t2);
manager.getFileSystem().add(childA, t3);
manager.getFileSystem().add(childB, t4);
manager.getFileSystem().add(childB, t5);
Assert.assertEquals(2955, root.getSize());
NodePrintVisitor visitor = new NodePrintVisitor();
root.accept(visitor);
}
public void setFolder(Folder newFolder) throws MessagingException {
if (folder != null) {
try {
folder.removeMessageCountListener(messageCountListener);
folder.close(true);
} catch (Exception ex) {
// Failure here seems to happen relatively often.
// enp has a corrupt folder, for example, and enh finds that Exchange seems to sometimes
// close folders on him, maybe because he's running Outlook at the same time.
// It's not currently obvious that there's much to be gained by showing this error to the
// user.
// It does seem that we should blunder on, rather than back out, because the UI's already
// been updated by this point.
// If we back out here, we really need to back out the UI change too, and going that route
// seems like a mistake.
ex.printStackTrace();
}
}
this.folder = newFolder;
this.messages = Collections.<Message>emptyList();
if (folder != null) {
scanWholeFolder();
folder.addMessageChangedListener(messageChangedListener);
folder.addMessageCountListener(messageCountListener);
}
}
public void add(String filePath, String languageName, String moduleName, int lineCount) {
// Get rid of Microsoft's incompatibility once and forever
filePath = filePath.replace("\\", DIRECTORY_SEPARATOR);
String folderPath = extractFolder(filePath);
File file = new File(filePath, languageName, moduleName, lineCount);
this.addFile(file);
Folder folder = this.getFolder(folderPath);
if (folder == null) {
folder = new Folder(folderPath);
this.addFolder(folder);
}
folder.addFile(file);
Language language = this.getLanguage(languageName);
if (language == null) {
language = new Language(languageName);
this.addLanguage(language);
}
language.addFile(file);
Module module = getModule(moduleName);
if (module == null) {
module = new Module(moduleName);
this.addModule(module);
}
module.addFile(file);
}
private boolean handleTouchDown(MotionEvent ev, boolean intercept) {
Rect hitRect = new Rect();
int x = (int) ev.getX();
int y = (int) ev.getY();
for (AppWidgetResizeFrame child : mResizeFrames) {
child.getHitRect(hitRect);
if (hitRect.contains(x, y)) {
if (child.beginResizeIfPointInRegion(x - child.getLeft(), y - child.getTop())) {
mCurrentResizeFrame = child;
mXDown = x;
mYDown = y;
requestDisallowInterceptTouchEvent(true);
return true;
}
}
}
Folder currentFolder = mLauncher.getWorkspace().getOpenFolder();
if (currentFolder != null && !mLauncher.isFolderClingVisible() && intercept) {
if (currentFolder.isEditingName()) {
if (!isEventOverFolderTextRegion(currentFolder, ev)) {
currentFolder.dismissEditingName();
return true;
}
}
getDescendantRectRelativeToSelf(currentFolder, hitRect);
if (!isEventOverFolder(currentFolder, ev)) {
mLauncher.closeFolder();
return true;
}
}
return false;
}
@Override
protected void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
if (mFolder == null) return;
if (mFolder.getItemCount() == 0 && !mAnimating) return;
ArrayList<View> items = mFolder.getItemsInReadingOrder(false);
Drawable d;
TextView v;
// Update our drawing parameters if necessary
if (mAnimating) {
computePreviewDrawingParams(mAnimParams.drawable);
} else {
v = (TextView) items.get(0);
d = v.getCompoundDrawables()[1];
computePreviewDrawingParams(d);
}
int nItemsInPreview = Math.min(items.size(), NUM_ITEMS_IN_PREVIEW);
if (!mAnimating) {
for (int i = nItemsInPreview - 1; i >= 0; i--) {
v = (TextView) items.get(i);
d = v.getCompoundDrawables()[1];
mParams = computePreviewItemDrawingParams(i, mParams);
mParams.drawable = d;
drawPreviewItem(canvas, mParams);
}
} else {
drawPreviewItem(canvas, mAnimParams);
}
}
private void add(final TreeEntry entry) {
String type = entry.getType();
String path = entry.getPath();
if (TextUtils.isEmpty(path)) return;
if (TYPE_BLOB.equals(type)) {
String[] segments = path.split("/");
if (segments.length > 1) {
Folder folder = folders.get(segments[0]);
if (folder != null) folder.addFile(entry, segments, 1);
} else if (segments.length == 1) {
Entry file = new Entry(entry, this);
files.put(file.name, file);
}
} else if (TYPE_TREE.equals(type)) {
String[] segments = path.split("/");
if (segments.length > 1) {
Folder folder = folders.get(segments[0]);
if (folder != null) folder.addFolder(entry, segments, 1);
} else if (segments.length == 1) {
Folder folder = new Folder(entry, this);
folders.put(folder.name, folder);
}
}
}
@Test
public void query2() {
Folder c1 = db.createFolder("/c1");
c1.documents().build(Name.create(db, "original")).elem("test").end("test").commit();
XMLDocument doc = c1.documents().get("original").xml();
doc.query().single("/test");
}
@Test
public void query3() {
Folder c1 = db.createFolder("/c1");
XMLDocument doc =
c1.documents().build(Name.create(db, "original")).elem("test").end("test").commit();
assertEquals(1, doc.query().all("/test").size());
}
@Test
public void testConstructor1() {
Folder folder = new Folder("Home", Visibility.PUBLIC, true);
Assert.assertEquals("Home", folder.getName());
Assert.assertEquals(Visibility.PUBLIC, folder.getVisibility());
Assert.assertTrue(folder.getVisibilityInCascade());
}
private void checkCurrentFolder(Folder folder) {
Preconditions.checkState(
folder.equals(currentFolder),
"You must have opened folder %s"
+ " before attempting to read from it (%s is currently open).",
folder.getName(),
(currentFolder == null ? "No folder" : currentFolder.getName()));
}
@Test
public void convertToSequence() {
Folder c = db.createFolder("/top");
c.documents().build(Name.create(db, "one")).elem("test").end("test").commit();
XMLDocument doc = c.documents().build(Name.create(db, "two")).elem("test").end("test").commit();
assertEquals(2, c.query().all("/test").size());
assertEquals(1, c.query().all("$_1/test", new Object[] {doc}).size());
}
@Test
public void delete1() {
Folder c1 = db.createFolder("/c1");
XMLDocument doc =
c1.documents().build(Name.create(db, "original")).elem("test").end("test").commit();
doc.delete();
assertEquals(0, c1.documents().size());
}
@Override
public Folder getFolder(String name) {
Folder folder = mFolders.get(name);
if (folder == null) {
folder = new Pop3Folder(name);
mFolders.put(folder.getName(), folder);
}
return folder;
}
public Folder getLongestFolder() {
Folder longest = null;
for (Folder f : this.getFolders()) {
if (longest == null || f.getLineCount() > longest.getLineCount()) {
longest = f;
}
}
return longest;
}
@Test
public void testAddFoldersWithConstructor2() {
Folder folder = new Folder("Home", Visibility.PUBLIC, true);
Folder folder1 = new Folder("Docs", Visibility.PUBLIC, true);
folder.add(folder1);
Assert.assertEquals("Docs", folder.getFolders().iterator().next().getName());
}
public String getPath() {
if (!mAcceptFiles) {
return mPath.getAbsolutePath();
} else if (mFilePath != null) {
return mFilePath.getAbsolutePath();
} else {
return null;
}
}
public AbstractMacroBaseUnitTestCase() {
// log4j:
PropertyConfigurator.configure(
AbstractMacroBaseUnitTestCase.class.getClassLoader().getResource("log4j.properties"));
// CMIS Repository
Map<String, ConfluenceCMISRepository> repoConfigs =
new WeakHashMap<String, ConfluenceCMISRepository>();
ConfluenceCMISRepository repoConfig =
new ConfluenceCMISRepository(
TEST_SERVER_NAME, TEST_REALM, TEST_USERNAME, TEST_PASSWORD, null);
repoConfigs.put(TEST_SERVER_NAME, repoConfig);
bandanaManager = mock(BandanaManager.class);
when(bandanaManager.getValue((BandanaContext) anyObject(), anyString()))
.thenReturn(repoConfigs);
// CMIS
ObjectId documentObjectId = mock(ObjectId.class);
when(documentObjectId.getId()).thenReturn(TEST_DOCUMENT_ID);
Document documentObject = getTestDocument();
List<CmisObject> documentList = new ArrayList<CmisObject>();
documentList.add(documentObject);
ObjectId folderObjectId = mock(ObjectId.class);
when(folderObjectId.getId()).thenReturn(TEST_FOLDER_ID);
ItemIterable<CmisObject> children = mock(ItemIterable.class);
when(children.getTotalNumItems()).thenReturn(1l);
when(children.getHasMoreItems()).thenReturn(true).thenReturn(false);
when(children.iterator()).thenReturn(documentList.iterator());
Folder folderObject =
createMockedCmisObject(
new String[][] {
{PropertyIds.NAME, "Name", "A folder"},
{PropertyIds.BASE_TYPE_ID, "Base Type Id", "cmis:folder"},
{PropertyIds.OBJECT_TYPE_ID, "Object Type Id", "cmis:folder"},
{PropertyIds.OBJECT_ID, "Object Type Id", TEST_FOLDER_ID}
},
Folder.class);
when(folderObject.getId()).thenReturn(TEST_FOLDER_ID);
when(folderObject.getChildren()).thenReturn(children);
Session session = mock(Session.class);
when(session.createObjectId(TEST_DOCUMENT_ID)).thenReturn(documentObjectId);
when(session.createObjectId(TEST_FOLDER_ID)).thenReturn(folderObjectId);
when(session.getObject(documentObjectId)).thenReturn(documentObject);
when(session.getObject(folderObjectId)).thenReturn(folderObject);
confluenceCMISRepository = mock(ConfluenceCMISRepository.class);
when(confluenceCMISRepository.getSession()).thenReturn(session);
}
/** Simplify the names. */
public void simplifyNames() {
String root = this.getRootFolder();
for (File f : this.getFiles()) {
f.simplifyName(root);
}
for (Folder f : this.getFolders()) {
f.simplifyName(root);
}
}
private void addFolder(TreeEntry entry, String[] pathSegments, int index) {
if (index == pathSegments.length - 1) {
Folder folder = new Folder(entry, this);
folders.put(folder.name, folder);
} else {
Folder folder = folders.get(pathSegments[index]);
if (folder != null) folder.addFolder(entry, pathSegments, index + 1);
}
}
private void addFile(TreeEntry entry, String[] pathSegments, int index) {
if (index == pathSegments.length - 1) {
Entry file = new Entry(entry, this);
files.put(file.name, file);
} else {
Folder folder = folders.get(pathSegments[index]);
if (folder != null) folder.addFile(entry, pathSegments, index + 1);
}
}
Long countOccurrencesOnSingleThread(Folder folder, String searchedWord) {
long count = 0;
for (Folder subFolder : folder.getSubFolders()) {
count = count + countOccurrencesOnSingleThread(subFolder, searchedWord);
}
for (Document document : folder.getDocuments()) {
count = count + occurrencesCount(document, searchedWord);
}
return count;
}
@Override
public boolean destroyFolder(String folderId) {
Folder instore = folderStore.remove(folderId);
if (null != instore) {
if (null != instore.changes) instore.changes.clear();
if (null != instore.children) instore.children.clear();
instore.maxChildId = -1;
}
return true;
}
@Test
public void testAddDocumentsIntoTheFolder() {
Folder folder = new Folder("Home", Visibility.PUBLIC, true);
Document doc = new Paper();
folder.addDocuments(doc);
Assert.assertEquals(folder.getDocuments().iterator().next().getName(), doc.getName());
}
private SortedSet<FolderChange> getFolderChangesInner(String folderId) {
Folder instore = getFolderInner(folderId);
if (null == instore.changes) {
synchronized (instore) {
if (null == instore.changes) {
instore.changes = new ConcurrentSkipListSet<FolderChange>();
}
}
}
return instore.changes;
}
private SortedSet<FolderChild> getChildrenInner(String folderId) {
Folder instore = getFolderInner(folderId);
if (null == instore.children) {
synchronized (instore) {
if (null == instore.children) {
instore.children = new ConcurrentSkipListSet<FolderChild>();
}
}
}
return instore.children;
}
public int handleFirstTime(
Account account,
FolderHelper folderHelper,
int folderDepth,
String messageStoreBucket,
Set<String> storedMessageIds,
String context,
StopWatch watch)
throws Exception {
int newMessages = 0;
Date lastMessageReceivedDate = null;
log.info(String.format("handling first mailcheck for %s", context));
Folder folder;
while ((folder = folderHelper.next()) != null) {
String folderContext = context + " ,folderName=" + folder.getFullName();
IMAPFolder imapFolder = (IMAPFolder) folder;
Collection<Integer> messages = getFirstTimeMessages(imapFolder, folderContext);
if (messages.size() > 0) {
storedMessageIds = new HashSet<String>();
for (Integer messageNumber : messages) {
Message message = imapFolder.getMessage(messageNumber);
if (lastMessageReceivedDate == null
|| lastMessageReceivedDate.before(message.getReceivedDate())) {
lastMessageReceivedDate = message.getReceivedDate();
}
String messageId = getId(account, imapFolder, message);
if (processMessage(
account,
message,
messageNumber,
messageId,
imapFolder,
storedMessageIds,
messageStoreBucket,
folderContext,
watch,
folderHelper)) {
newMessages++;
}
}
}
}
updateAccount(account, null, 0, folderDepth, lastMessageReceivedDate);
return newMessages;
}
private Folder getFolderInner(String folderId) {
Folder instore = folderStore.get(folderId);
if (null == instore) {
synchronized (folderStore) {
if (!folderStore.containsKey(folderId)) {
instore = new Folder(folderId);
instore.maxChildId = 0;
folderStore.put(folderId, instore);
}
}
}
return instore;
}
