<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You 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.
-->

<!DOCTYPE html>
<html>
   <head>
      <title>Readme File Tests</title>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <link rel="stylesheet" href="resources/css/bootstrap-combined.min.css" />
      <link rel="stylesheet" href="resources/css/styles.css" />
      <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js" type="text/javascript"></script>
      <script src="../usergrid.js" type="text/javascript"></script>
      <script src="test.js" type="text/javascript"></script>
      <script type="text/javascript">

      </script>
   </head>
   <body>
      <div class="header">
         <img src="resources/images/apigee.png"> App Services (Usergrid) Javascript SDK
      </div>
      <div class="info">
      This sample application runs tests on the sample code examples in the readme file.  Tests are run against App Services (Usergrid) using the Usergrid Javascript SDK.
      </div>
    <div id="main" class="main">
      <div class="section-header">README sample code tests</div>
      <div class="well">
        <div id="name-control" class="control-group">
          <div class="controls">
            <button class="btn btn-primary" id="start-button" style="width: 90px;">Start</button>
            <span style="clear: both;">&nbsp;</span>
          </div>
        </div>
      </div>
      <div class="section-header"><b>Test Output</b></div>
      <div class="well">
        <pre id="test-output">// Press Start button to begin</pre>
      </div>
    </body>
</html>
