Merge branch 'master' of https://github.com/github/linguist

Conflicts:
	lib/linguist/languages.yml

samples/Bluespec/TL.bsv

@@ -0,0 +1,167 @@
+package TL;
+
+interface TL;
+   method Action ped_button_push();
+
+         (* always_enabled *)
+         method Action set_car_state_N(Bool x);
+         (* always_enabled *)
+         method Action set_car_state_S(Bool x);
+         (* always_enabled *)
+         method Action set_car_state_E(Bool x);
+         (* always_enabled *)
+         method Action set_car_state_W(Bool x);
+
+   method Bool lampRedNS();
+   method Bool lampAmberNS();
+   method Bool lampGreenNS();
+
+   method Bool lampRedE();
+   method Bool lampAmberE();
+   method Bool lampGreenE();
+
+   method Bool lampRedW();
+   method Bool lampAmberW();
+   method Bool lampGreenW();
+
+   method Bool lampRedPed();
+   method Bool lampAmberPed();
+   method Bool lampGreenPed();
+endinterface: TL
+
+typedef enum {
+         AllRed,
+         GreenNS, AmberNS,
+         GreenE, AmberE,
+         GreenW, AmberW,
+         GreenPed, AmberPed} TLstates deriving (Eq, Bits);
+
+typedef UInt#(5) Time32;
+typedef UInt#(20) CtrSize;
+
+(* synthesize *)
+module sysTL(TL);
+   Time32 allRedDelay = 2;
+   Time32 amberDelay = 4;
+   Time32 nsGreenDelay = 20;
+   Time32 ewGreenDelay = 10;
+   Time32 pedGreenDelay = 10;
+   Time32 pedAmberDelay = 6;
+
+   CtrSize clocks_per_sec = 100;
+
+   Reg#(TLstates) state <- mkReg(AllRed);
+   Reg#(TLstates) next_green <- mkReg(GreenNS);
+   Reg#(Time32) secs <- mkReg(0);
+   Reg#(Bool) ped_button_pushed <- mkReg(False);
+         Reg#(Bool) car_present_N <- mkReg(True);
+   Reg#(Bool) car_present_S <- mkReg(True);
+   Reg#(Bool) car_present_E <- mkReg(True);
+   Reg#(Bool) car_present_W <- mkReg(True);
+         Bool car_present_NS = car_present_N || car_present_S;
+   Reg#(CtrSize) cycle_ctr <- mkReg(0);
+
+   rule dec_cycle_ctr (cycle_ctr != 0);
+      cycle_ctr <= cycle_ctr - 1;
+   endrule
+
+   Rules low_priority_rule = (rules
+                        rule inc_sec (cycle_ctr == 0);
+                                 secs <= secs + 1;
+                                 cycle_ctr <= clocks_per_sec;
+                        endrule endrules);
+
+   function Action next_state(TLstates ns);
+         action
+                                 state <= ns;
+                                 secs <= 0;
+      endaction
+   endfunction: next_state
+
+   function TLstates green_seq(TLstates x);
+      case (x)
+                                 GreenNS: return (GreenE);
+                                 GreenE:  return (GreenW);
+                                 GreenW:  return (GreenNS);
+      endcase
+   endfunction
+
+   function Bool car_present(TLstates x);
+      case (x)
+                                 GreenNS: return (car_present_NS);
+                                 GreenE:  return (car_present_E);
+                                 GreenW:  return (car_present_W);
+      endcase
+   endfunction
+
+   function Rules make_from_green_rule(TLstates green_state, Time32 delay, Bool car_is_present, TLstates ns);
+                        return (rules
+                                 rule from_green (state == green_state && (secs >= delay || !car_is_present));
+                                                next_state(ns);
+                                 endrule endrules);
+   endfunction: make_from_green_rule
+
+   function Rules make_from_amber_rule(TLstates amber_state, TLstates ng);
+      return (rules
+                                 rule from_amber (state == amber_state && secs >= amberDelay);
+                                                next_state(AllRed);
+                                                next_green <= ng;
+                                 endrule endrules);
+   endfunction: make_from_amber_rule
+
+   Rules hprs[7];
+
+   hprs[1] = make_from_green_rule(GreenNS, nsGreenDelay, car_present_NS, AmberNS);
+   hprs[2] = make_from_amber_rule(AmberNS, GreenE);
+   hprs[3] = make_from_green_rule(GreenE, ewGreenDelay, car_present_E, AmberE);
+   hprs[4] = make_from_amber_rule(AmberE, GreenW);
+   hprs[5] = make_from_green_rule(GreenW, ewGreenDelay, car_present_W, AmberW);
+   hprs[6] = make_from_amber_rule(AmberW, GreenNS);
+
+         hprs[0] = (rules
+                        rule fromAllRed (state == AllRed && secs >= allRedDelay);
+                                 if (ped_button_pushed) action
+                                                ped_button_pushed <= False;
+                                                next_state(GreenPed);
+                                 endaction else if (car_present(next_green))
+                              next_state(next_green);
+                           else if (car_present(green_seq(next_green)))
+                                    next_state(green_seq(next_green));
+         else if (car_present(green_seq(green_seq(next_green))))
+                                    next_state(green_seq(green_seq(next_green)));
+         else
+                                    noAction;
+                        endrule: fromAllRed endrules);
+
+         Rules high_priority_rules = hprs[0];
+   for (Integer i = 1; i<7; i=i+1)
+      high_priority_rules = rJoin(hprs[i], high_priority_rules);
+
+         addRules(preempts(high_priority_rules, low_priority_rule));
+
+   method Action ped_button_push();
+      ped_button_pushed <= True;
+   endmethod: ped_button_push
+
+   method Action set_car_state_N(b) ; car_present_N <= b; endmethod
+   method Action set_car_state_S(b) ; car_present_S <= b; endmethod
+   method Action set_car_state_E(b) ; car_present_E <= b; endmethod
+   method Action set_car_state_W(b) ; car_present_W <= b; endmethod
+
+   method lampRedNS() = (!(state == GreenNS || state == AmberNS));
+   method lampAmberNS() = (state == AmberNS);
+   method lampGreenNS() = (state == GreenNS);
+   method lampRedE() = (!(state == GreenE || state == AmberE));
+   method lampAmberE() = (state == AmberE);
+   method lampGreenE() = (state == GreenE);
+   method lampRedW() = (!(state == GreenW || state == AmberW));
+   method lampAmberW() = (state == AmberW);
+   method lampGreenW() = (state == GreenW);
+
+   method lampRedPed() = (!(state == GreenPed || state == AmberPed));
+   method lampAmberPed() = (state == AmberPed);
+   method lampGreenPed() = (state == GreenPed);
+
+endmodule: sysTL
+
+endpackage: TL

samples/Bluespec/TbTL.bsv

@@ -0,0 +1,109 @@
+package TbTL;
+
+import TL::*;
+
+interface Lamp;
+   method Bool changed;
+   method Action show_offs;
+   method Action show_ons;
+   method Action reset;
+endinterface
+
+module mkLamp#(String name, Bool lamp)(Lamp);
+   Reg#(Bool) prev <- mkReg(False);
+
+   method changed = (prev != lamp);
+
+   method Action show_offs;
+      if (prev && !lamp)
+      $write (name + " off, ");
+   endmethod
+
+   method Action show_ons;
+      if (!prev && lamp)
+      $write (name + " on, ");
+   endmethod
+
+   method Action reset;
+      prev <= lamp;
+   endmethod
+endmodule
+
+
+(* synthesize *)
+module mkTest();
+   let dut <- sysTL;
+
+   Reg#(Bit#(16)) ctr <- mkReg(0);
+
+   Reg#(Bool) carN <- mkReg(False);
+   Reg#(Bool) carS <- mkReg(False);
+   Reg#(Bool) carE <- mkReg(False);
+   Reg#(Bool) carW <- mkReg(False);
+
+   Lamp lamps[12];
+
+   lamps[0] <- mkLamp("0:  NS  red  ", dut.lampRedNS);
+   lamps[1] <- mkLamp("1:  NS  amber", dut.lampAmberNS);
+   lamps[2] <- mkLamp("2:  NS  green", dut.lampGreenNS);
+   lamps[3] <- mkLamp("3:  E   red  ", dut.lampRedE);
+   lamps[4] <- mkLamp("4:  E   amber", dut.lampAmberE);
+   lamps[5] <- mkLamp("5:  E   green", dut.lampGreenE);
+   lamps[6] <- mkLamp("6:  W   red  ", dut.lampRedW);
+   lamps[7] <- mkLamp("7:  W   amber", dut.lampAmberW);
+   lamps[8] <- mkLamp("8:  W   green", dut.lampGreenW);
+
+   lamps[9]  <- mkLamp("9:  Ped red  ", dut.lampRedPed);
+   lamps[10] <- mkLamp("10: Ped amber", dut.lampAmberPed);
+   lamps[11] <- mkLamp("11: Ped green", dut.lampGreenPed);
+
+   rule start (ctr == 0);
+      $dumpvars;
+   endrule
+
+   rule detect_cars;
+      dut.set_car_state_N(carN);
+      dut.set_car_state_S(carS);
+      dut.set_car_state_E(carE);
+      dut.set_car_state_W(carW);
+   endrule
+
+   rule go;
+      ctr <= ctr + 1;
+      if (ctr == 5000) carN <= True;
+      if (ctr == 6500) carN <= False;
+      if (ctr == 12_000) dut.ped_button_push;
+   endrule
+
+   rule stop (ctr > 32768);
+      $display("TESTS FINISHED");
+      $finish(0);
+   endrule
+
+   function do_offs(l) = l.show_offs;
+      function do_ons(l) = l.show_ons;
+      function do_reset(l) = l.reset;
+
+      function do_it(f);
+         action
+         for (Integer i=0; i<12; i=i+1)
+            f(lamps[i]);
+         endaction
+      endfunction
+
+      function any_changes();
+         Bool b = False;
+         for (Integer i=0; i<12; i=i+1)
+             b = b || lamps[i].changed;
+         return b;
+      endfunction
+
+      rule show (any_changes());
+      do_it(do_offs);
+      do_it(do_ons);
+      do_it(do_reset);
+      $display("(at time %d)", $time);
+   endrule
+endmodule
+
+endpackage

samples/C/jni_layer.h

@@ -0,0 +1,61 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class jni_JniLayer */
+
+#ifndef _Included_jni_JniLayer
+#define _Included_jni_JniLayer
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     jni_JniLayer
+ * Method:    jni_layer_initialize
+ * Signature: ([II)J
+ */
+JNIEXPORT jlong JNICALL Java_jni_JniLayer_jni_1layer_1initialize
+  (JNIEnv *, jobject, jintArray, jint, jint);
+
+/*
+ * Class:     jni_JniLayer
+ * Method:    jni_layer_mainloop
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jni_JniLayer_jni_1layer_1mainloop
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     jni_JniLayer
+ * Method:    jni_layer_set_button
+ * Signature: (JII)V
+ */
+JNIEXPORT void JNICALL Java_jni_JniLayer_jni_1layer_1set_1button
+  (JNIEnv *, jobject, jlong, jint, jint);
+
+/*
+ * Class:     jni_JniLayer
+ * Method:    jni_layer_set_analog
+ * Signature: (JIIF)V
+ */
+JNIEXPORT void JNICALL Java_jni_JniLayer_jni_1layer_1set_1analog
+  (JNIEnv *, jobject, jlong, jint, jint, jfloat);
+
+/*
+ * Class:     jni_JniLayer
+ * Method:    jni_layer_report_analog_chg
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL Java_jni_JniLayer_jni_1layer_1report_1analog_1chg
+  (JNIEnv *, jobject, jlong, jint);
+
+/*
+ * Class:     jni_JniLayer
+ * Method:    jni_layer_kill
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jni_JniLayer_jni_1layer_1kill
+  (JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

samples/C/syscalldefs.h

@@ -0,0 +1,5 @@
+static const syscalldef syscalldefs[] = {
+        [SYSCALL_OR_NUM(0, SYS_restart_syscall)]        = MAKE_UINT16(0, 1),
+        [SYSCALL_OR_NUM(1, SYS_exit)]         = MAKE_UINT16(1, 17),
+        [SYSCALL_OR_NUM(2, SYS_fork)]         = MAKE_UINT16(0, 22),
+};

samples/Clojure/for.clj

@@ -0,0 +1,17 @@
+(defn prime? [n]
+   (not-any? zero? (map #(rem n %) (range 2 n))))
+
+(range 3 33 2)
+'(3 5 7 9 11 13 15 17 19 21 23 25 27 29 31)
+
+;; :when continues through the collection even if some have the
+;; condition evaluate to false, like filter
+(for [x (range 3 33 2) :when (prime? x)]
+   x)
+'(3 5 7 11 13 17 19 23 29 31)
+
+;; :while stops at the first collection element that evaluates to
+;; false, like take-while
+(for [x (range 3 33 2) :while (prime? x)]
+   x)
+'(3 5 7)

samples/Clojure/hiccup.hic

@@ -0,0 +1,8 @@
+[:html
+ [:head
+  [:meta {:charset "utf-8"}]
+  [:link {:rel "stylesheet" :href "css/bootstrap.min.css"}]
+  [:script {:src "app.js"}]]
+ [:body
+  [:div.nav
+   [:p "Hello world!"]]]]

samples/Clojure/into-array.cljc

@@ -0,0 +1,13 @@
+(defn into-array
+  ([aseq]
+     (into-array nil aseq))
+  ([type aseq]
+     (let [n (count aseq)
+           a (make-array n)]
+       (loop [aseq (seq aseq)
+              i 0]
+         (if (< i n)
+           (do
+             (aset a i (first aseq))
+             (recur (next aseq) (inc i)))
+           a)))))

samples/Clojure/protocol.cljs

@@ -0,0 +1,15 @@
+(defprotocol ISound (sound []))
+ 
+(deftype Cat []
+  ISound
+  (sound [_] "Meow!"))
+ 
+(deftype Dog []
+  ISound
+  (sound [_] "Woof!"))
+ 
+(extend-type default
+  ISound
+  (sound [_] "... silence ..."))
+ 
+(sound 1) ;; => "... silence ..."

samples/Clojure/rand.cljscm

@@ -0,0 +1,5 @@
+(defn rand
+  "Returns a random floating point number between 0 (inclusive) and
+  n (default 1) (exclusive)."
+  ([] (scm* [n] (random-real)))
+  ([n] (* (rand) n)))

samples/Clojure/svg.cljx

@@ -0,0 +1,20 @@
+^:clj (ns c2.svg
+        (:use [c2.core :only [unify]]
+              [c2.maths :only [Pi Tau radians-per-degree
+                               sin cos mean]]))
+
+^:cljs (ns c2.svg
+         (:use [c2.core :only [unify]]
+               [c2.maths :only [Pi Tau radians-per-degree
+                                sin cos mean]])
+         (:require [c2.dom :as dom]))
+
+;;Stub for float fn, which does not exist on cljs runtime
+^:cljs (def float identity)
+
+(defn ->xy
+  "Convert coordinates (potentially map of `{:x :y}`) to 2-vector."
+  [coordinates]
+  (cond
+   (and (vector? coordinates) (= 2 (count coordinates))) coordinates
+   (map? coordinates) [(:x coordinates) (:y coordinates)]))

samples/Clojure/unit-test.cl2

@@ -0,0 +1,20 @@
+(deftest function-tests
+  (is (= 3
+         (count [1 2 3])))
+  (is (= false
+         (not true)))
+  (is (= true
+         (contains? {:foo 1 :bar 2} :foo)))
+
+  (is (= {"foo" 1, "baz" 3}
+         (select-keys {:foo 1 :bar 2 :baz 3} [:foo :baz])))
+
+  (is (= [1 2 3]
+         (vals {:foo 1 :bar 2 :baz 3})))
+
+  (is (= ["foo" "bar" "baz"]
+         (keys {:foo 1 :bar 2 :baz 3})))
+
+  (is (= [2 4 6]
+         (filter (fn [x] (=== (rem x 2) 0)) [1 2 3 4 5 6]))))
+

samples/Common Lisp/sample.lisp

@@ -0,0 +1,21 @@
+;;;; -*- lisp -*-
+
+(in-package :foo)
+
+;;; Header comment.
+(defvar *foo*)
+
+(eval-when (:execute :compile-toplevel :load-toplevel)
+  (defun add (x &optional y &key z)
+    (declare (ignore z))
+    ;; Inline comment.
+    (+ x (or y 1))))
+
+#|
+Multi-line comment.
+|#
+
+(defmacro foo (x &body b)
+  (if x
+      `(1+ ,x)   ;After-line comment.
+      42))

samples/DM/example.dm

@@ -0,0 +1,87 @@
+// This is a single line comment.
+/*
+	This is a multi-line comment
+*/
+
+// Pre-processor keywords
+
+#define PI 3.1415
+
+#if PI == 4
+
+#define G 5
+
+#elif PI == 3
+
+#define I 6
+
+#else
+
+#define K 7
+
+#endif
+
+
+var/GlobalCounter = 0
+var/const/CONST_VARIABLE = 2
+var/list/MyList = list("anything", 1, new /datum/entity)
+var/list/EmptyList[99] // creates a list of 99 null entries
+var/list/NullList = null
+
+/*
+	Entity Class
+*/
+
+/datum/entity
+	var/name = "Entity"
+	var/number = 0
+
+/datum/entity/proc/myFunction()
+	world.log << "Entity has called myFunction"
+
+/datum/entity/New()
+	number = GlobalCounter++
+
+/*
+	Unit Class, Extends from Entity
+*/
+
+/datum/entity/unit
+	name = "Unit"
+
+/datum/entity/unit/New()
+	..() // calls the parent's proc; equal to super() and base() in other languages
+	number = rand(1, 99)
+
+/datum/entity/unit/myFunction()
+	world.log << "Unit has overriden and called myFunction"
+
+// Global Function
+/proc/ReverseList(var/list/input)
+	var/list/output = list()
+	for(var/i = input.len; i >= 1; i--) // IMPORTANT: List Arrays count from 1.
+		output += input[i] // "+= x" is ".Add(x)"
+	return output
+
+// Bitflags
+/proc/DoStuff()
+	var/bitflag = 0
+	bitflag |= 8
+	return bitflag
+
+/proc/DoOtherStuff()
+	var/bitflag = 65535 // 16 bits is the maximum amount
+	bitflag &= ~8
+	return bitflag
+
+// Logic
+/proc/DoNothing()
+	var/pi = PI
+	if(pi == 4)
+		world.log << "PI is 4"
+	else if(pi == CONST_VARIABLE)
+		world.log << "PI is [CONST_VARIABLE]!"
+	else
+		world.log << "PI is approximety [pi]"
+
+#undef PI // Undefine PI

samples/Idris/Chars.idr

@@ -0,0 +1,42 @@
+module Prelude.Char
+
+import Builtins
+
+isUpper : Char -> Bool
+isUpper x = x >= 'A' && x <= 'Z'
+
+isLower : Char -> Bool
+isLower x = x >= 'a' && x <= 'z'
+
+isAlpha : Char -> Bool
+isAlpha x = isUpper x || isLower x
+
+isDigit : Char -> Bool
+isDigit x = (x >= '0' && x <= '9')
+
+isAlphaNum : Char -> Bool
+isAlphaNum x = isDigit x || isAlpha x
+
+isSpace : Char -> Bool
+isSpace x = x == ' '  || x == '\t' || x == '\r' ||
+            x == '\n' || x == '\f' || x == '\v' ||
+            x == '\xa0'
+
+isNL : Char -> Bool
+isNL x = x == '\r' || x == '\n'
+
+toUpper : Char -> Char
+toUpper x = if (isLower x)
+               then (prim__intToChar (prim__charToInt x - 32))
+               else x
+
+toLower : Char -> Char
+toLower x = if (isUpper x)
+               then (prim__intToChar (prim__charToInt x + 32))
+               else x
+
+isHexDigit : Char -> Bool
+isHexDigit x = elem (toUpper x) hexChars where
+  hexChars : List Char
+  hexChars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+              'A', 'B', 'C', 'D', 'E', 'F']

samples/Jade/hello.jade

@@ -0,0 +1,3 @@
+p.
+  Hello,
+  World!

samples/KRL/helloworld.krl

@@ -0,0 +1,15 @@
+ruleset sample {
+  meta {
+    name "Hello World"
+    description <<
+Hello world
+>>
+    author "Phil Windley"
+  }
+
+  // just one rule
+  rule hello {
+    select when web pageview
+    notify("Hello world!", "Just a note to say hello");
+  }
+}

samples/OpenCL/sample.cl

@@ -0,0 +1,23 @@
+/* Old-style comment. */
+
+// New-style comment.
+
+typedef float foo_t;
+
+#ifndef ZERO
+#define ZERO (0.0)
+#endif
+
+#define FOO(x) ((x) + \
+  ZERO)
+
+__kernel
+void foo(__global const foo_t * x, __local foo_t y, const uint n)
+{
+  barrier(CLK_LOCAL_MEM_FENCE);
+
+  if (n > 42) {
+    *x += y;
+  }
+}
+

samples/Protocol Buffer/addressbook.proto

@@ -0,0 +1,27 @@
+package tutorial;
+
+option java_package = "com.example.tutorial";
+option java_outer_classname = "AddressBookProtos";
+
+message Person {
+  required string name = 1;
+  required int32 id = 2;
+  optional string email = 3;
+
+  enum PhoneType {
+    MOBILE = 0;
+    HOME = 1;
+    WORK = 2;
+  }
+
+  message PhoneNumber {
+    required string number = 1;
+    optional PhoneType type = 2 [default = HOME];
+  }
+
+  repeated PhoneNumber phone = 4;
+}
+
+message AddressBook {
+  repeated Person person = 1;
+}

samples/RobotFramework/data_driven.robot

@@ -0,0 +1,45 @@
+*** Settings ***
+Documentation     Example test cases using the data-driven testing approach.
+...
+...               Tests use `Calculate` keyword created in this file, that in
+...               turn uses keywords in `CalculatorLibrary`. An exception is
+...               the last test that has a custom _template keyword_.
+...
+...               The data-driven style works well when you need to repeat
+...               the same workflow multiple times.
+...
+...               Notice that one of these tests fails on purpose to show how
+...               failures look like.
+Test Template     Calculate
+Library           CalculatorLibrary
+
+*** Test Cases ***    Expression    Expected
+Addition              12 + 2 + 2    16
+                      2 + -3        -1
+
+Subtraction           12 - 2 - 2    8
+                      2 - -3        5
+
+Multiplication        12 * 2 * 2    48
+                      2 * -3        -6
+
+Division              12 / 2 / 2    3
+                      2 / -3        -1
+
+Failing               1 + 1         3
+
+Calculation error     [Template]    Calculation should fail
+                      kekkonen      Invalid button 'k'.
+                      ${EMPTY}      Invalid expression.
+                      1 / 0         Division by zero.
+
+*** Keywords ***
+Calculate
+    [Arguments]    ${expression}    ${expected}
+    Push buttons    C${expression}=
+    Result should be    ${expected}
+
+Calculation should fail
+    [Arguments]    ${expression}    ${expected}
+    ${error} =    Should cause error    C${expression}=
+    Should be equal    ${expected}    ${error}    # Using `BuiltIn` keyword

samples/RobotFramework/gherkin.robot

@@ -0,0 +1,33 @@
+*** Settings ***
+Documentation     Example test case using the gherkin syntax.
+...
+...               This test has a workflow similar to the keyword-driven
+...               examples. The difference is that the keywords use higher
+...               abstraction level and their arguments are embedded into
+...               the keyword names.
+...
+...               This kind of _gherkin_ syntax has been made popular by
+...               [http://cukes.info|Cucumber]. It works well especially when
+...               tests act as examples that need to be easily understood also
+...               by the business people.
+Library           CalculatorLibrary
+
+*** Test Cases ***
+Addition
+    Given calculator has been cleared
+    When user types "1 + 1"
+    and user pushes equals
+    Then result is "2"
+
+*** Keywords ***
+Calculator has been cleared
+    Push button    C
+
+User types "${expression}"
+    Push buttons    ${expression}
+
+User pushes equals
+    Push button    =
+
+Result is "${result}"
+    Result should be    ${result}

samples/RobotFramework/keyword_driven.robot

@@ -0,0 +1,37 @@
+*** Settings ***
+Documentation     Example test cases using the keyword-driven testing approach.
+...
+...               All tests contain a workflow constructed from keywords in
+...               `CalculatorLibrary`. Creating new tests or editing existing
+...               is easy even for people without programming skills.
+...
+...               This kind of style works well for normal test automation.
+...               If also business people need to understand tests, using
+...               _gherkin_ style may work better.
+Library           CalculatorLibrary
+
+*** Test Cases ***
+Push button
+    Push button    1
+    Result should be    1
+
+Push multiple buttons
+    Push button    1
+    Push button    2
+    Result should be    12
+
+Simple calculation
+    Push button    1
+    Push button    +
+    Push button    2
+    Push button    =
+    Result should be    3
+
+Longer calculation
+    Push buttons    5 + 4 - 3 * 2 / 1 =
+    Result should be    3
+
+Clear
+    Push button    1
+    Push button    C
+    Result should be    ${EMPTY}    # ${EMPTY} is a built-in variable

samples/Scaml/hello.scaml

@@ -0,0 +1,3 @@
+%p
+  Hello,
+  World!

samples/TypeScript/hello.ts

@@ -1 +1 @@
-console.log "Hello, World!"
+console.log("Hello, World!");