NotebookTestScript.dib

#!markdown

# Execute the following cell.

You'll notice a counter that appears and starts incrementing.  After a second or two, stop the cell.  Your output should look similar to:

```
5
Comamnd cancelled
```

#!csharp

using System.Threading.Tasks;
using Microsoft.DotNet.Interactive;

var output = string.Empty.Display("text/plain");
var counter = 1;
while (!KernelInvocationContext.Current.CancellationToken.IsCancellationRequested)
{
    await Task.Delay(500, KernelInvocationContext.Current.CancellationToken);
    output.Update($"{counter++}");
}

#!markdown

# Execute the next two cells.

#!csharp

var x = 123;

#!html

<div id="output">The value is not yet set.</div>

#!markdown

# Execute the next cell.  After execution, the output immediately above this should read:

```
The value is 123.
```

And the output below the next cell should display the same value.

#!javascript

const x = await interactive.csharp.getVariable("x");
document.getElementById("output").innerText = `The value is ${x}.`;
console.log(`The value is ${x}.`);

#!markdown

# Execute the next cell, the output should be displayed as JSON like so:

``` json
{"Name":"Developer","Salary":42}
```

#!csharp

display(new { Name = "Developer", Salary = 42 }, "application/json");

#!markdown

# Execute the next cell and verify the following error appears:

```
input.fsx (1,11)-(1,12) parse error Unexpected token '+' or incomplete expression
```

#!fsharp

let x = 1 +

#!markdown

# Complex console output

#!markdown

The output should look like:

<span style="color:#00FF00">this is green</span>

this is white

<span style="color:#FF0000">this is red</span>

#!csharp

Console.Write("\x1b[38;2;0;255;0m");
Console.WriteLine("this is green");
Console.Write("\x1b[0m");
"this is white".Display();
Console.Error.Write("\x1b[38;2;255;0;0m");
Console.Error.WriteLine("this is red");
Console.Error.Write("\x1b[0m");

#!markdown

# vscode kernel
This cell should prompt the user for input

#!csharp

var input = await GetInputAsync("give me data");
input

#!fsharp

let input = GetInputAsync "give me data" false |> Async.RunSynchronously
input

#!markdown

Test adding cell to notebook (VSCode only)

#!csharp

using Microsoft.DotNet.Interactive;
using Microsoft.DotNet.Interactive.Commands;

var _ = Kernel.Root.SendAsync(new SendEditableCode("markdown","# this is a markdown cell."));

#!markdown

# Check this manual scenario:

1. `Ctrl+Shift+P` => ".NET Interactive: Create new blank notebook"
2. Select "Create as .dib"
3. Select "F#"
4. You should have a new empty notebook named something like "Untitled-1.dib" with a single cell of type "F# (Interactive)".
5. Set the cell contents to `1+1` and execute.
6. Verify output of `2`.
7. Save to disk.
8. Open that file in notepad.
9. The contents should look like this:

   ```
   #!fsharp

   1+1
   ```

#!markdown

# Execute the above scenario again with the following changes:

2. Select "Create as .ipynb"
4. File should be named something like "Untitled-1.ipynb".

(new steps)

9. The contents should look like this:

``` json
{
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (F#)",
   "language": "F#",
   "name": ".net-fsharp"
  },
  "language_info": {
   "name": "F#"
  }
 },
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "1+1"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">2</div>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   }
  }
 ],
 "nbformat": 4,
 "nbformat_minor": 2
}
```

#!markdown

# Open the two previously saved notebooks via the following:

1. `Ctrl+Shift+P` => ".NET Interactive: Open notebook"
2. Select the "Untitled-1.dib"/"Untitled-1.ipynb" from before.
3. Verify that it contains a single F# cell with the contents "1+1" and that it can execute.