diff --git a/src/com/google/enterprise/adaptor/sharepoint/AuthenticationResult.java b/src/com/google/enterprise/adaptor/sharepoint/AuthenticationResult.java
new file mode 100644
index 0000000..0e86c0e
--- /dev/null
+++ b/src/com/google/enterprise/adaptor/sharepoint/AuthenticationResult.java
@@ -0,0 +1,44 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+package com.google.enterprise.adaptor.sharepoint;
+
+public class AuthenticationResult {
+  private final String cookie;
+  private final int cookieTimeOut;
+  private final String errorCode;
+
+  public AuthenticationResult(String cookie,
+      int cookieTimeOut, String errorCode) {
+    if (cookieTimeOut <= 0) {
+      throw new IllegalArgumentException();
+    }
+    this.cookie = cookie;
+    this.cookieTimeOut = cookieTimeOut;
+    this.errorCode = errorCode;      
+  }
+
+  public String getCookie() {
+    return cookie;
+  }
+
+  public int getCookieTimeOut() {
+    return cookieTimeOut;
+  }
+
+  public String getErrorCode() {
+    return errorCode;
+  }
+}
diff --git a/src/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandler.java b/src/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandler.java
index 035dafc..a223818 100644
--- a/src/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandler.java
+++ b/src/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandler.java
@@ -16,24 +16,15 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Strings;
-import com.microsoft.schemas.sharepoint.soap.authentication.AuthenticationMode;
-import com.microsoft.schemas.sharepoint.soap.authentication.AuthenticationSoap;
-import com.microsoft.schemas.sharepoint.soap.authentication.LoginErrorCode;
-import com.microsoft.schemas.sharepoint.soap.authentication.LoginResult;
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import javax.xml.ws.BindingProvider;
-import javax.xml.ws.WebServiceException;
-import javax.xml.ws.handler.MessageContext;
-
 
 /**
  * Helper class to handle forms authentication.
@@ -54,19 +45,19 @@
   private final Runnable refreshRunnable = new RefreshRunnable();  
   private final List<String> authenticationCookiesList 
       = new CopyOnWriteArrayList<String>();
-  private AuthenticationMode authenticationMode;
-  private final AuthenticationSoap authenticationClient;
-  
+  private final AuthenticationHandler authenticationClient;
+  private boolean isFormsAuthentication = false;
+
   @VisibleForTesting    
   FormsAuthenticationHandler(String userName, String password,
       ScheduledExecutorService executor,
-      AuthenticationSoap authenticationClient) {
+      AuthenticationHandler authenticationClient) {
     if (userName == null || password == null || executor == null || 
         authenticationClient == null) {
       throw new NullPointerException();
     }
     this.userName = userName;
-    this.password = password;   
+    this.password = password;
     this.executor = executor;
     this.authenticationClient = authenticationClient;
   }
@@ -76,54 +67,38 @@
   }
   
   public boolean isFormsAuthentication() {
-    return authenticationMode == AuthenticationMode.FORMS;
+    return isFormsAuthentication;
   }
   
   private void refreshCookies() throws IOException {
-    log.log(Level.FINE, "AuthenticationMode = {0}", authenticationMode);
-    if (authenticationMode != AuthenticationMode.FORMS) {
-      return;
-    }
     
     if ("".equals(userName) || "".equals(password)) {
       log.log(Level.FINE, 
           "Empty username / password. Using authentication mode as Windows");
-       authenticationMode = AuthenticationMode.WINDOWS;
+       isFormsAuthentication = false;
        return;
     }
-    
-    LoginResult result;
-    try {
-      result = authenticationClient.login(userName, password);
-    } catch (WebServiceException ex) {
-      log.log(Level.WARNING,
-          "Possible SP2013 environment with windows authentication", ex);
-      authenticationMode = AuthenticationMode.WINDOWS;
+
+    if (!isFormsAuthentication) {
       return;
     }
-    log.log(Level.FINE, 
-        "Login Cookie Expiration in = {0}", result.getTimeoutSeconds());
-    if (result.getErrorCode() != LoginErrorCode.NO_ERROR) {
-      log.log(Level.WARNING, "Forms authentication failed with authentication "
-          + "web service with Error Code {0}. Possible SharePoint environment "
-          + "with multiple claims provider. Adaptor might have been configured "
-          + "to use windows authentication.", result.getErrorCode());
+
+    log.log(Level.FINE, "About to refresh authentication cookie.");
+    AuthenticationResult result = authenticationClient.authenticate();
+    log.log(Level.FINE, "Authentication Result {0}", result.getErrorCode());
+
+    String cookie = result.getCookie();
+    if (Strings.isNullOrEmpty(cookie)) {
+      log.log(Level.INFO, "Authentication cookie is null or empty."
+          + " Adaptor will use Windows authentication.");
       return;
     }
-    @SuppressWarnings("unchecked")
-    Map<String, Object> responseHeaders
-        = (Map<String, Object>) ((BindingProvider) authenticationClient)
-        .getResponseContext().get(MessageContext.HTTP_RESPONSE_HEADERS);
-    log.log(Level.FINEST, "Response headers: {0}", responseHeaders);
-    @SuppressWarnings("unchecked")
-    String cookies = ((List<String>) responseHeaders.get("Set-cookie")).get(0);
     if (authenticationCookiesList.isEmpty()) {
-      authenticationCookiesList.add(cookies);
+      authenticationCookiesList.add(cookie);
     } else {
-      authenticationCookiesList.set(0, cookies);
+      authenticationCookiesList.set(0, cookie);
     }
-    long cookieTimeOut = (result.getTimeoutSeconds() == null) ? 
-        DEFAULT_COOKIE_TIMEOUT_SECONDS : result.getTimeoutSeconds();
+    long cookieTimeOut = result.getCookieTimeOut();
 
     long rerunAfter = (cookieTimeOut + 1) / 2;
     executor.schedule(refreshRunnable, rerunAfter, TimeUnit.SECONDS);
@@ -132,7 +107,13 @@
  }
  
   public void start() throws IOException {
-    authenticationMode = authenticationClient.mode();
+    if ("".equals(userName) || "".equals(password)) {
+      log.log(Level.FINE, "Empty username or password. Using windows"
+          + " integrated authentication.");
+       isFormsAuthentication = false;
+       return;
+    }
+    isFormsAuthentication = authenticationClient.isFormsAuthentication();
     refreshCookies();
   }
 
@@ -148,4 +129,9 @@
       }
     }
   }
-}
+  
+  interface AuthenticationHandler {
+    AuthenticationResult authenticate() throws IOException;
+    boolean isFormsAuthentication() throws IOException;
+  }  
+}
\ No newline at end of file
diff --git a/src/com/google/enterprise/adaptor/sharepoint/SharePointAdaptor.java b/src/com/google/enterprise/adaptor/sharepoint/SharePointAdaptor.java
index 4500ef4..22fc5eb 100644
--- a/src/com/google/enterprise/adaptor/sharepoint/SharePointAdaptor.java
+++ b/src/com/google/enterprise/adaptor/sharepoint/SharePointAdaptor.java
@@ -474,9 +474,12 @@
     scheduledExecutor = new ScheduledThreadPoolExecutor(1);
     String authenticationEndPoint = spUrlToUri(
         virtualServer + "/_vti_bin/Authentication.asmx").toString();
+    SharePointFormsAuthenticationHandler authenticationClient 
+        = new SharePointFormsAuthenticationHandler(
+            soapFactory.newAuthentication(authenticationEndPoint),
+            username, password);
     authenticationHandler = new FormsAuthenticationHandler(username,
-        password, scheduledExecutor,
-        soapFactory.newAuthentication(authenticationEndPoint));
+        password, scheduledExecutor, authenticationClient);
     authenticationHandler.start();
     executor = executorFactory.call();
     try {
diff --git a/src/com/google/enterprise/adaptor/sharepoint/SharePointFormsAuthenticationHandler.java b/src/com/google/enterprise/adaptor/sharepoint/SharePointFormsAuthenticationHandler.java
new file mode 100644
index 0000000..c3c9406
--- /dev/null
+++ b/src/com/google/enterprise/adaptor/sharepoint/SharePointFormsAuthenticationHandler.java
@@ -0,0 +1,131 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.enterprise.adaptor.sharepoint;
+
+import com.google.enterprise.adaptor.sharepoint.FormsAuthenticationHandler.AuthenticationHandler;
+import com.microsoft.schemas.sharepoint.soap.authentication.AuthenticationMode;
+import com.microsoft.schemas.sharepoint.soap.authentication.AuthenticationSoap;
+import com.microsoft.schemas.sharepoint.soap.authentication.LoginErrorCode;
+import com.microsoft.schemas.sharepoint.soap.authentication.LoginResult;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.xml.ws.BindingProvider;
+import javax.xml.ws.WebServiceException;
+import javax.xml.ws.handler.MessageContext;
+
+/**
+ * AuthenticationHandler implementation for SharePoint forms authentication
+ * using Authentication.asmx web service.
+*/
+public class SharePointFormsAuthenticationHandler 
+    implements AuthenticationHandler {
+  private static final Logger log
+      = Logger.getLogger(SharePointFormsAuthenticationHandler.class.getName());
+  // Default time out for forms authentication with .NET is 30 mins
+  private static final int DEFAULT_COOKIE_TIMEOUT_SECONDS = 30 * 60;
+  private final AuthenticationSoap authenticationClient;
+  private AuthenticationMode authenticationMode;
+  private final String username;
+  private final String password;
+
+  SharePointFormsAuthenticationHandler(AuthenticationSoap authenticationClient,
+      String username, String password) {
+    if (authenticationClient == null || username == null || password == null) {
+      throw new NullPointerException();
+    }
+    this.authenticationClient = authenticationClient;
+    this.username = username;
+    this.password = password;
+  }
+
+  public AuthenticationResult authenticate() throws IOException {
+    if (!isFormsAuthentication()) {
+      return new AuthenticationResult(null, DEFAULT_COOKIE_TIMEOUT_SECONDS,
+          LoginErrorCode.NOT_IN_FORMS_AUTHENTICATION_MODE.toString());
+    }
+    LoginResult result;
+    try {
+      result = authenticationClient.login(username, password);
+    } catch (WebServiceException ex) {
+      log.log(Level.WARNING,
+          "Forms authentication failed.", ex);
+      log.log(Level.INFO, "Possible SharePoint environment configured to use "
+          + "claims based windows integrated authentication. "
+          + "Adaptor will fallback to use windows integrated authentication.");      
+      return new AuthenticationResult(null, DEFAULT_COOKIE_TIMEOUT_SECONDS,
+          LoginErrorCode.NOT_IN_FORMS_AUTHENTICATION_MODE.toString());
+    }
+
+    log.log(Level.FINE,
+        "Login Cookie Expiration in = {0}", result.getTimeoutSeconds());
+    if (result.getErrorCode() != LoginErrorCode.NO_ERROR) {
+      log.log(Level.WARNING, "Forms authentication failed with error code {0}. "
+          + "Possible SharePoint environment with multiple claims providers. "
+          + "Adaptor will fallback to use windows integrated authentication.",
+          result.getErrorCode());      
+      return new AuthenticationResult(null, DEFAULT_COOKIE_TIMEOUT_SECONDS,
+          result.getErrorCode().toString());
+    }
+
+    @SuppressWarnings("unchecked")
+    Map<String, Object> responseHeaders
+        = (Map<String, Object>) ((BindingProvider) authenticationClient)
+        .getResponseContext().get(MessageContext.HTTP_RESPONSE_HEADERS);
+    log.log(Level.FINEST, "Response headers: {0}", responseHeaders);
+    if(!responseHeaders.containsKey("Set-cookie")) {
+      throw new IOException("Unable to extract authentication cookie.");
+    }
+    
+    @SuppressWarnings("unchecked")
+    List<String> cookies = (List<String>) responseHeaders.get("Set-cookie");
+    if (cookies == null || cookies.isEmpty()) {
+      throw new IOException("Unable to extract authentication cookie.");
+    }
+    
+    int cookieTimeout;
+    // On SP2007 result.getTimeoutSeconds() can be null
+    if (result.getTimeoutSeconds() == null) {
+      log.log(Level.FINE,
+          "Login cookie timeout is null. Using default cookie timeout.");
+      cookieTimeout = DEFAULT_COOKIE_TIMEOUT_SECONDS;
+    } else {
+      cookieTimeout = result.getTimeoutSeconds() > 0 
+          ? result.getTimeoutSeconds() : DEFAULT_COOKIE_TIMEOUT_SECONDS;
+    }
+    
+    log.log(Level.FINE,
+        "Login Cookie Expiration in = {0} seconds", cookieTimeout);
+ 
+    return new AuthenticationResult(cookies.get(0), cookieTimeout,
+        result.getErrorCode().toString());
+  }
+
+  public boolean isFormsAuthentication() throws IOException {
+    if (authenticationMode == null) {
+      // Cache authentication mode value to avoid repetitive web service 
+      // calls to get authentication mode.     
+      setAuthenticationMode(authenticationClient.mode());
+      log.log(Level.FINE, "Authentication Mode {0}", authenticationMode);
+    }
+    return authenticationMode == AuthenticationMode.FORMS;
+  }
+  
+  private synchronized void setAuthenticationMode(AuthenticationMode mode) {
+    authenticationMode = mode;
+  }
+}
diff --git a/src/com/google/enterprise/adaptor/sharepoint/SharePointUserProfileAdaptor.java b/src/com/google/enterprise/adaptor/sharepoint/SharePointUserProfileAdaptor.java
index 5ff3932..c4e3b87 100644
--- a/src/com/google/enterprise/adaptor/sharepoint/SharePointUserProfileAdaptor.java
+++ b/src/com/google/enterprise/adaptor/sharepoint/SharePointUserProfileAdaptor.java
@@ -226,9 +226,13 @@
     Authenticator.setDefault(ntlmAuthenticator);
     String authenticationEndPoint 
         =  virtualServer + "/_vti_bin/Authentication.asmx";
+    SharePointFormsAuthenticationHandler authenticationClient 
+        = new SharePointFormsAuthenticationHandler(
+            userProfileServiceFactory.newAuthentication(authenticationEndPoint),
+            username, password); 
     FormsAuthenticationHandler authenticationHandler 
         = new FormsAuthenticationHandler(username, password, scheduledExecutor,
-        userProfileServiceFactory.newAuthentication(authenticationEndPoint));
+        authenticationClient);
     authenticationHandler.start();
     log.log(Level.FINEST, "Initializing User profile Service Client for {0}",
         virtualServer + USER_PROFILE_SERVICE_ENDPOINT);
diff --git a/test/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandlerTest.java b/test/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandlerTest.java
new file mode 100644
index 0000000..84ec9da
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/sharepoint/FormsAuthenticationHandlerTest.java
@@ -0,0 +1,200 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.enterprise.adaptor.sharepoint;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.enterprise.adaptor.sharepoint.FormsAuthenticationHandler.AuthenticationHandler;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+public class FormsAuthenticationHandlerTest {
+  
+  @Rule
+  public ExpectedException thrown = ExpectedException.none();
+  
+  private static class UnsupportedAuthenticationHandler 
+      implements AuthenticationHandler {
+
+    public AuthenticationResult authenticate() throws IOException {
+      throw new UnsupportedOperationException();
+    }
+
+    public boolean isFormsAuthentication() throws IOException {
+      throw new UnsupportedOperationException();
+    }
+  }
+  
+  private static class MockAuthenticationHandler 
+      extends UnsupportedAuthenticationHandler {
+    
+    private boolean isFormsAuthentication;
+    private AuthenticationResult authenticationResult;
+    
+    MockAuthenticationHandler(boolean isFormsAuthentication,
+        AuthenticationResult authenticationResult) {
+      this.isFormsAuthentication = isFormsAuthentication;
+      this.authenticationResult = authenticationResult;      
+    }
+
+    @Override
+    public AuthenticationResult authenticate() throws IOException {
+      if (authenticationResult == null) {
+        throw new UnsupportedOperationException();
+      }
+      return authenticationResult;
+    }
+
+    @Override
+    public boolean isFormsAuthentication() throws IOException {
+      return isFormsAuthentication;
+    }
+  }
+  
+  private static class UnsupportedScheduledExecutor extends CallerRunsExecutor 
+      implements ScheduledExecutorService {
+
+    public ScheduledFuture<?> schedule(Runnable command, long delay,
+        TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay,
+        TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
+        long initialDelay, long period, TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
+        long initialDelay, long delay, TimeUnit unit) {
+      throw new UnsupportedOperationException(); 
+    }
+    
+  }
+  
+  private static class MockScheduledExecutor 
+      extends UnsupportedScheduledExecutor {
+    long executionDelay;
+    TimeUnit executionTimeUnit;   
+    
+    @Override
+    public ScheduledFuture<?> schedule(Runnable command, long delay,
+        TimeUnit unit) {
+      executionDelay = delay;
+      executionTimeUnit = unit;
+      return null;
+    }
+  }
+  
+  @Test
+  public void testConstructor() {
+    new FormsAuthenticationHandler("username", "password",
+        new UnsupportedScheduledExecutor(),
+        new UnsupportedAuthenticationHandler());
+  }
+  
+  @Test
+  public void testNullUserName() {
+    thrown.expect(NullPointerException.class);
+    new FormsAuthenticationHandler(null, "password",
+        new UnsupportedScheduledExecutor(),
+        new UnsupportedAuthenticationHandler());
+  }
+  
+  @Test
+  public void testNullPassword() {
+    thrown.expect(NullPointerException.class);
+    new FormsAuthenticationHandler("username", null,
+        new UnsupportedScheduledExecutor(),
+        new UnsupportedAuthenticationHandler());
+  }
+  
+  @Test
+  public void testNullScheduledExecutor() {
+    thrown.expect(NullPointerException.class);
+    new FormsAuthenticationHandler("username", "password", null,
+        new UnsupportedAuthenticationHandler());
+  }
+  
+  @Test
+  public void testNullAuthenticationHandler() {
+    thrown.expect(NullPointerException.class);
+    new FormsAuthenticationHandler("username", "password",
+        new UnsupportedScheduledExecutor(),null);
+  }
+  
+  @Test
+  public void testWindowsAuthentication() throws IOException {
+    FormsAuthenticationHandler formsHandler = new FormsAuthenticationHandler(
+        "username", "password",  new UnsupportedScheduledExecutor(),
+        new MockAuthenticationHandler(false, null));
+    formsHandler.start();
+    assertFalse(formsHandler.isFormsAuthentication());
+    assertTrue(formsHandler.getAuthenticationCookies().isEmpty());
+  }
+  
+  @Test
+  public void testEmptyUsernamePassword() throws IOException {
+    FormsAuthenticationHandler formsHandler = new FormsAuthenticationHandler(
+        "", "",  new UnsupportedScheduledExecutor(),
+        new UnsupportedAuthenticationHandler());
+    formsHandler.start();
+    assertFalse(formsHandler.isFormsAuthentication());
+    assertTrue(formsHandler.getAuthenticationCookies().isEmpty());
+  }
+  
+  @Test
+  public void testFormsAuthenticationNoError() throws IOException {
+    MockScheduledExecutor executor = new MockScheduledExecutor();    
+    FormsAuthenticationHandler formsHandler = new FormsAuthenticationHandler(
+        "username", "password", executor, new MockAuthenticationHandler(true,
+            new AuthenticationResult("AuthenCookie", 99, "NO_ERROR")));
+    formsHandler.start();
+    assertTrue(formsHandler.isFormsAuthentication());
+    assertEquals(Collections.unmodifiableList(Arrays.asList("AuthenCookie")),
+        formsHandler.getAuthenticationCookies());
+    assertEquals(50, executor.executionDelay);
+    assertEquals(TimeUnit.SECONDS, executor.executionTimeUnit);
+    executor.shutdown();
+  }
+  
+  @Test
+  public void testFormsAuthenticationPasswordMismatch() throws IOException {
+    FormsAuthenticationHandler formsHandler = new FormsAuthenticationHandler(
+        "username", "password", new UnsupportedScheduledExecutor(),
+        new MockAuthenticationHandler(true,
+            new AuthenticationResult(null, 99, "PASSWORD_NOT_MATCH")));
+    formsHandler.start();
+    assertTrue(formsHandler.isFormsAuthentication());
+    assertTrue(formsHandler.getAuthenticationCookies().isEmpty());
+  }
+}
diff --git a/test/com/google/enterprise/adaptor/sharepoint/SharePointFormsAuthenticationHandlerTest.java b/test/com/google/enterprise/adaptor/sharepoint/SharePointFormsAuthenticationHandlerTest.java
new file mode 100644
index 0000000..fb9251f
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/sharepoint/SharePointFormsAuthenticationHandlerTest.java
@@ -0,0 +1,191 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.enterprise.adaptor.sharepoint;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.microsoft.schemas.sharepoint.soap.authentication.AuthenticationMode;
+import com.microsoft.schemas.sharepoint.soap.authentication.AuthenticationSoap;
+import com.microsoft.schemas.sharepoint.soap.authentication.LoginErrorCode;
+import com.microsoft.schemas.sharepoint.soap.authentication.LoginResult;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.ws.Binding;
+import javax.xml.ws.BindingProvider;
+import javax.xml.ws.EndpointReference;
+import javax.xml.ws.handler.MessageContext;
+
+public class SharePointFormsAuthenticationHandlerTest {
+  @Rule
+  public ExpectedException thrown = ExpectedException.none();
+  
+  private static class UnsupportedAuthenticationSoap 
+      implements AuthenticationSoap {
+
+    public LoginResult login(String username, String password) {
+      throw new UnsupportedOperationException();
+    }
+
+    public AuthenticationMode mode() {
+      throw new UnsupportedOperationException(); 
+    }    
+  }
+  
+  private static class MockFormsAuthenticationSoap 
+      extends UnsupportedAuthenticationSoap implements BindingProvider {
+    @Override
+    public LoginResult login(String username, String password) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public AuthenticationMode mode() {
+      return AuthenticationMode.FORMS; 
+    }
+
+    public Map<String, Object> getRequestContext() {
+      throw new UnsupportedOperationException(); 
+    }
+
+    public Map<String, Object> getResponseContext() {
+      throw new UnsupportedOperationException();
+    }
+
+    public Binding getBinding() {
+      throw new UnsupportedOperationException();
+    }
+
+    public EndpointReference getEndpointReference() {
+      throw new UnsupportedOperationException();
+    }
+
+    public <T extends EndpointReference> T 
+        getEndpointReference(Class<T> clazz) {
+      throw new UnsupportedOperationException();
+    }
+  }
+  
+  @Test
+  public void testConstructor() {
+    new SharePointFormsAuthenticationHandler (
+        new UnsupportedAuthenticationSoap(), "username", "password");
+  }
+  
+  @Test
+  public void testNullUserName() {
+    thrown.expect(NullPointerException.class);
+    new SharePointFormsAuthenticationHandler (
+        new UnsupportedAuthenticationSoap(), null, "password");
+  }
+  
+  @Test
+  public void testNullPassword() {
+    thrown.expect(NullPointerException.class);
+    new SharePointFormsAuthenticationHandler (
+        new UnsupportedAuthenticationSoap(), "username", null);
+  }
+  
+  @Test
+  public void testNullAuthenticationClient() {
+    thrown.expect(NullPointerException.class);
+    new SharePointFormsAuthenticationHandler ( null, "username", "password");
+  }
+  
+  @Test
+  public void testSharePointWithWindowsAuthentication() throws IOException{
+    SharePointFormsAuthenticationHandler authenHandler 
+        = new SharePointFormsAuthenticationHandler(
+            new MockFormsAuthenticationSoap(){
+                @Override public AuthenticationMode mode()
+                {
+                  return AuthenticationMode.WINDOWS;
+                }
+            }, "username", "password");
+    
+    assertFalse(authenHandler.isFormsAuthentication());
+    AuthenticationResult ar = authenHandler.authenticate();
+    assertNotNull(ar);
+    assertNull(ar.getCookie());
+    assertEquals(LoginErrorCode.NOT_IN_FORMS_AUTHENTICATION_MODE.toString(),
+        ar.getErrorCode());
+  }
+  
+  @Test
+  public void testSharePointWithFormsPasswordMismatch() throws IOException {
+    SharePointFormsAuthenticationHandler authenHandler 
+        = new SharePointFormsAuthenticationHandler(
+            new MockFormsAuthenticationSoap(){                
+                @Override public LoginResult login(
+                    String username, String password) {
+                  LoginResult lr = new LoginResult();
+                  lr.setErrorCode(LoginErrorCode.PASSWORD_NOT_MATCH);
+                  return lr;                  
+                }
+            }, "username", "password");
+    
+    assertTrue(authenHandler.isFormsAuthentication());
+    AuthenticationResult ar = authenHandler.authenticate();
+    assertNotNull(ar);
+    assertNull(ar.getCookie());
+    assertEquals(LoginErrorCode.PASSWORD_NOT_MATCH.toString(),
+        ar.getErrorCode());
+  }
+  
+  @Test
+  public void testSharePointWithFormsAuthentication() throws IOException {
+    SharePointFormsAuthenticationHandler authenHandler 
+        = new SharePointFormsAuthenticationHandler(
+            new MockFormsAuthenticationSoap() {
+              @Override public LoginResult login(
+                    String username, String password) {
+                LoginResult lr = new LoginResult();
+                lr.setErrorCode(LoginErrorCode.NO_ERROR);
+                return lr;                  
+              }
+              
+              @Override public Map<String, Object> getResponseContext() {
+                Map<String, Object> responseContext 
+                    = new HashMap<String, Object>();
+                Map<String, List<String>> responseHeaders 
+                    = new HashMap<String, List<String>>();
+                responseHeaders.put("Set-cookie",
+                    Arrays.asList("AuthenticationCookie"));      
+                responseContext.put(MessageContext.HTTP_RESPONSE_HEADERS,
+                    Collections.unmodifiableMap(responseHeaders));
+                return  Collections.unmodifiableMap(responseContext);                
+              }
+            }, "username", "password");
+    assertTrue(authenHandler.isFormsAuthentication());
+    AuthenticationResult ar = authenHandler.authenticate();
+    assertNotNull(ar);
+    assertEquals("AuthenticationCookie", ar.getCookie());
+    assertEquals(LoginErrorCode.NO_ERROR.toString(),
+        ar.getErrorCode());
+  }
+}