diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..2f7cd07f
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+ghc*.tar.xz filter=lfs diff=lfs merge=lfs -text
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8ebb8c9f..a585ab45 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -4,6 +4,10 @@ env:
   # Bump this number to invalidate the Github-actions cache
   cache-invalidation-key: 0
   nixpkgs-url: https://github.com/NixOS/nixpkgs/archive/574d1eac1c200690e27b8eb4e24887f8df7ac27c.tar.gz
+  NIX_PATH: https://github.com/NixOS/nixpkgs/archive/574d1eac1c200690e27b8eb4e24887f8df7ac27c.tar.gz
+  ghc-exe: $(pwd)/ghc-dps-compact-702220602b/bin/ghc
+  ghc-name: ghc-dps-compact-702220602b
+  ghc-internal-name: ghc-9.11.20240917-x86_64-unknown-linux
 
 jobs:
   cabal-test:
@@ -13,7 +17,9 @@ jobs:
         ghc-version: [96, 98, 910]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
+      with:
+        lfs: false
     - uses: cachix/install-nix-action@v15
       with:
         nix_path: "${{ env.nixpkgs-url }}"
@@ -52,11 +58,50 @@ jobs:
           benchmark_ghc${{ matrix.ghc-version }}.txt
         retention-days: 90
 
+  cabal-test-ghc-dps-compact:
+    name: cabal test - ${{ env.ghc-name }}
+    runs-on: [self-hosted, Linux, X64]
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        lfs: true
+    - name: Checkout LFS objects
+      run: git lfs checkout
+    - name: Build Nix dependencies
+      run: nix-shell --arg installHls 'false' --pure --run "echo '=== Nix dependencies installed ==='"
+    - name: Install custom GHC
+      run: nix-shell --pure --run "rm -rf ${{ env.ghc-name }} ${{ env.ghc-internal-name }} && tar xJf ${{ env.ghc-name }}.tar.xz && mv ${{ env.ghc-internal-name }} ${{ env.ghc-name }}"
+    - name: Init Cabal's config file
+      run: nix-shell --arg installHls 'false' --pure --run "cabal --config-file=$HOME/.cabal/config user-config -f init"
+    - name: Update Cabal's database
+      run: nix-shell --arg installHls 'false' --pure --run "cabal update"
+    - name: Build Cabal's dependencies
+      run: nix-shell --arg installHls 'false' --pure --run "cabal build -w ${{ env.ghc-exe }} --dependencies-only"
+    - name: Build
+      run: nix-shell --arg installHls 'false' --pure --run "cabal build -w ${{ env.ghc-exe }}"
+    - name: Haddock
+      run: nix-shell --arg installHls 'false' --pure --run "cabal haddock -w ${{ env.ghc-exe }}"
+    - name: cabal-docspec
+      run: nix-shell --arg installHls 'false' --pure --run "cabal-docspec -w ${{ env.ghc-exe }}"
+    - name: Build benchmarks
+      run: nix-shell --arg installHls 'false' --pure --run "cabal build linear-base:bench:bench"
+    - name: Run benchmarks
+      run: nix-shell --arg installHls 'false' --pure --run "cabal bench 2>&1 | tee benchmark_${{ env.ghc-name }}.txt"
+    - name: Upload benchmark results
+      uses: actions/upload-artifact@v3
+      with:
+        name: linear-base_benchmarks_${{ env.ghc-name }}
+        path: |
+          benchmark_${{ env.ghc-name }}.txt
+        retention-days: 90
+
   ormolu:
     name: check formatting with ormolu
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
+      with:
+        lfs: false
     - uses: cachix/install-nix-action@v15
       with:
         nix_path: "${{ env.nixpkgs-url }}"
@@ -75,7 +120,9 @@ jobs:
     name: stack build
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
+      with:
+        lfs: false
     - uses: cachix/install-nix-action@v15
       with:
         nix_path: "${{ env.nixpkgs-url }}"
diff --git a/.gitignore b/.gitignore
index 64f6907a..9bbfd33b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,3 +22,5 @@ cabal.sandbox.config
 .stack-work/
 cabal.project.local
 .HTF/
+
+ghc-dps-compact-702220602b
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact.hs
new file mode 100644
index 00000000..12e19a5d
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact.hs
@@ -0,0 +1,20 @@
+module Bench.Compact where
+
+import Test.Tasty.Bench
+
+import Bench.Compact.BFTraversal (bftraversalBenchgroup)
+import Bench.Compact.Map (mapBenchgroup)
+import Bench.Compact.DList (dlistBenchgroup)
+import Bench.Compact.Queue (queueBenchgroup)
+import Bench.Compact.SExpr (sexprBenchgroup)
+
+benchmarks :: Benchmark
+benchmarks =
+  bgroup
+    "DPS interface for compact regions"
+    [ bftraversalBenchgroup
+    , mapBenchgroup
+    , dlistBenchgroup
+    , queueBenchgroup
+    , sexprBenchgroup
+    ]
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact/BFTraversal.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/BFTraversal.hs
new file mode 100644
index 00000000..b17f1a31
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/BFTraversal.hs
@@ -0,0 +1,24 @@
+module Bench.Compact.BFTraversal where
+
+import Compact.BFTraversal as BFTraversal
+import Bench.Compact.Utils as Utils
+import Control.Exception (evaluate)
+import Control.DeepSeq (force)
+import Test.Tasty.Bench (Benchmark)
+
+dataSets :: [(IO (BinTree ()), String)]
+dataSets =
+  [ (evaluate $ force (go 0 10), "2^10")
+  , (evaluate $ force (go 0 13), "2^13")
+  , (evaluate $ force (go 0 16), "2^16")
+  , (evaluate $ force (go 0 19), "2^19")
+  , (evaluate $ force (go 0 22), "2^22")
+  ]
+  where
+      go :: Int -> Int -> BinTree ()
+      go currentDepth maxDepth =
+        if currentDepth >= maxDepth
+          then Nil
+          else Node () (go (currentDepth + 1) maxDepth) (go (currentDepth + 1) maxDepth)
+
+bftraversalBenchgroup = Utils.benchImpls BFTraversal.impls dataSets
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact/DList.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/DList.hs
new file mode 100644
index 00000000..0433b389
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/DList.hs
@@ -0,0 +1,18 @@
+module Bench.Compact.DList where
+
+import Compact.DList as DList
+import Bench.Compact.Utils as Utils
+import Control.Exception (evaluate)
+import Control.DeepSeq (force)
+import Test.Tasty.Bench (Benchmark)
+
+dataSets :: [(IO [[Int]], String)]
+dataSets =
+  [ (evaluate $ force (fmap (\i -> [(10 * i + 0)..(10 * i + 9)]) [0..(((2^10) `div` 10) - 1)]), "2^10")
+  , (evaluate $ force (fmap (\i -> [(10 * i + 0)..(10 * i + 9)]) [0..(((2^13) `div` 10) - 1)]), "2^13")
+  , (evaluate $ force (fmap (\i -> [(10 * i + 0)..(10 * i + 9)]) [0..(((2^16) `div` 10) - 1)]), "2^16")
+  , (evaluate $ force (fmap (\i -> [(10 * i + 0)..(10 * i + 9)]) [0..(((2^19) `div` 10) - 1)]), "2^19")
+  , (evaluate $ force (fmap (\i -> [(10 * i + 0)..(10 * i + 9)]) [0..(((2^22) `div` 10) - 1)]), "2^22")
+  ]
+
+dlistBenchgroup = benchImpls DList.impls dataSets
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Map.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Map.hs
new file mode 100644
index 00000000..483bdd82
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Map.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE LinearTypes #-}
+module Bench.Compact.Map where
+
+import Compact.Map as Map
+import Bench.Compact.Utils as Utils
+import Control.Exception (evaluate)
+import Control.DeepSeq (force)
+import Test.Tasty.Bench (Benchmark)
+
+dataSets :: [(IO (Int %1 -> Int, [Int]), String)]
+dataSets =
+  [ ((\x -> 2 * x + 1,) <$> (evaluate $ force [1 .. 2^10]), "2^10")
+  , ((\x -> 2 * x + 1,) <$> (evaluate $ force [1 .. 2^13]), "2^13")
+  , ((\x -> 2 * x + 1,) <$> (evaluate $ force [1 .. 2^16]), "2^16")
+  , ((\x -> 2 * x + 1,) <$> (evaluate $ force [1 .. 2^19]), "2^19")
+  , ((\x -> 2 * x + 1,) <$> (evaluate $ force [1 .. 2^22]), "2^22")
+  ]
+
+mapBenchgroup = benchImpls Map.impls dataSets
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Queue.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Queue.hs
new file mode 100644
index 00000000..8865c0fd
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Queue.hs
@@ -0,0 +1,18 @@
+module Bench.Compact.Queue where
+
+import Compact.Queue as Queue
+import Bench.Compact.Utils as Utils
+import Control.Exception (evaluate)
+import Control.DeepSeq (force)
+import Test.Tasty.Bench (Benchmark)
+
+dataSets :: [(IO Word64, String)]
+dataSets =
+  [ (return $ 2^10, "2^10")
+  , (return $ 2^13, "2^13")
+  , (return $ 2^16, "2^16")
+  , (return $ 2^19, "2^19")
+  , (return $ 2^22, "2^22")
+  ]
+
+queueBenchgroup = benchImpls Queue.impls dataSets
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact/SExpr.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/SExpr.hs
new file mode 100644
index 00000000..4c37e02b
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/SExpr.hs
@@ -0,0 +1,22 @@
+module Bench.Compact.SExpr where
+
+import Compact.SExpr as SExpr
+import Bench.Compact.Utils as Utils
+import Control.Exception (evaluate)
+import Control.DeepSeq (force)
+import qualified Data.ByteString.Char8 as BSC
+import Test.Tasty.Bench (Benchmark)
+
+dataSetDir :: String
+dataSetDir = "bench-version-changes/ghc-dps-compact/after/datasets/"
+
+dataSets :: [(IO ByteString, String)]
+dataSets =
+  [ (evaluate . force =<< BSC.readFile (dataSetDir ++ "data_2_10.sexpr"), "2^10")
+  , (evaluate . force =<< BSC.readFile (dataSetDir ++ "data_2_13.sexpr"), "2^13")
+  , (evaluate . force =<< BSC.readFile (dataSetDir ++ "data_2_16.sexpr"), "2^16")
+  , (evaluate . force =<< BSC.readFile (dataSetDir ++ "data_2_19.sexpr"), "2^19")
+  , (evaluate . force =<< BSC.readFile (dataSetDir ++ "data_2_22.sexpr"), "2^22")
+  ]
+
+sexprBenchgroup = Utils.benchImpls SExpr.impls dataSets
diff --git a/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Utils.hs b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Utils.hs
new file mode 100644
index 00000000..4f675bdf
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/Bench/Compact/Utils.hs
@@ -0,0 +1,80 @@
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module Bench.Compact.Utils where
+
+import Control.DeepSeq
+import Test.Tasty (TestTree, testGroup)
+import Test.Tasty.HUnit (testCaseInfo, assertEqual)
+import Test.Tasty.Bench
+import Control.Exception (evaluate)
+import Data.Functor ((<&>))
+import GHC.Compact (compact, getCompact)
+
+import qualified Compact.Map as Map
+import qualified Compact.BFTraversal as BFTraversal
+import qualified Compact.DList as DList
+import qualified Compact.Queue as Queue
+import qualified Compact.SExpr as SExpr
+
+import qualified Bench.Compact.Map as Map
+import qualified Bench.Compact.BFTraversal as BFTraversal
+import qualified Bench.Compact.DList as DList
+import qualified Bench.Compact.Queue as Queue
+import qualified Bench.Compact.SExpr as SExpr
+
+benchImpls :: forall m a r. (NFData r) => String -> [(a %m -> r, String, Bool)] -> [(IO a, String)] -> Benchmark
+benchImpls name impls datasets = do
+  bgroup name (
+    datasets <&> \(loadSampleData, sizeName) -> env loadSampleData $ \sampleData ->
+      testGroup sizeName $ concat $ impls <&> \(impl, implName, isLazy) -> if isLazy
+          then
+            [ bench (implName ++ ".force") $ (flip whnfAppIO) sampleData $ \sampleData -> evaluate $ force $ impl sampleData,
+              bench (implName ++ ".copyIntoReg") $ (flip whnfAppIO) sampleData $ \sampleData -> do
+                    resInRegion <- compact $ impl sampleData
+                    evaluate $ getCompact $ resInRegion
+            ]
+          else
+            [ bench implName $ (flip whnfAppIO) sampleData $ \sampleData -> evaluate $ impl sampleData ])
+
+launchImpl :: String -> IO ()
+launchImpl s =
+  let (_all, dotModuleName) = span (/= '.') s
+      (moduleName, dotBenchmark) = span (/= '.') (tail dotModuleName)
+      (_benchmark, dotImplSizeSpec) = span (/= '.') (tail dotBenchmark)
+      implSizeSpec = tail dotImplSizeSpec
+   in case (_all ++ "." ++ moduleName ++ "." ++ _benchmark) of
+        "All.Bench.Compact.Map.benchmark" -> Utils.launchImpl' implSizeSpec Map.impls Map.dataSets
+        "All.Bench.Compact.BFTraversal.benchmark" -> Utils.launchImpl' implSizeSpec BFTraversal.impls BFTraversal.dataSets
+        "All.Bench.Compact.DList.benchmark" -> Utils.launchImpl' implSizeSpec DList.impls DList.dataSets
+        "All.Bench.Compact.Queue.benchmark" -> Utils.launchImpl' implSizeSpec Queue.impls Queue.dataSets
+        "All.Bench.Compact.SExpr.benchmark" -> Utils.launchImpl' implSizeSpec SExpr.impls SExpr.dataSets
+        s' -> error ("benchmark group '" ++ s' ++ "' not found")
+
+launchImpl' :: forall m a r. (NFData r) => String -> [(a %m -> r, String, Bool)] -> [(IO a, String)] -> IO ()
+launchImpl' requestedImplDataSetspec impls datasets = go impls (go' datasets) where
+  (requestedSize, dotRequestedImplSpec) = span (/= '.') requestedImplDataSetspec
+  (requestedImplRadical, requestedImplVariant) = span (/= '.') (tail dotRequestedImplSpec)
+  go [] _ = error ("requested implementation '" ++ requestedImplRadical ++ "' not found")
+  go ((impl, implName, isLazy):_) loadSampleData | implName == requestedImplRadical = do
+    sampleData <- loadSampleData
+    if isLazy
+      then case requestedImplVariant of
+        ".force" -> evaluate $ rwhnf $ force $ impl sampleData
+        ".copyIntoReg" -> do
+          resInRegion <- compact $ impl sampleData
+          evaluate $ rwhnf $ getCompact $ resInRegion
+        _ -> error ("variant '" ++ requestedImplVariant ++ "' not found (required for lazy impl)")
+    else
+      evaluate $ rwhnf $ impl sampleData
+    putStrLn "Done!"
+  go (_:xs) loadSampleData = go xs loadSampleData
+
+  go' [] = error ("requested size '" ++ requestedSize ++ "' not found")
+  go' ((loadSampleData, sizeName):_) | sizeName == requestedSize = loadSampleData
+  go' (_:xs) = go' xs
diff --git a/bench-version-changes/ghc-dps-compact/after/datasets/data_2_10.sexpr b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_10.sexpr
new file mode 100644
index 00000000..da68ee25
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_10.sexpr
@@ -0,0 +1,46 @@
+(
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+)
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/after/datasets/data_2_13.sexpr b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_13.sexpr
new file mode 100644
index 00000000..284df694
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_13.sexpr
@@ -0,0 +1,354 @@
+(
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+)
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/after/datasets/data_2_16.sexpr b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_16.sexpr
new file mode 100644
index 00000000..e0155e74
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_16.sexpr
@@ -0,0 +1,2774 @@
+(
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+)
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/after/datasets/data_2_19.sexpr b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_19.sexpr
new file mode 100644
index 00000000..1af378ae
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_19.sexpr
@@ -0,0 +1,22090 @@
+(
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+)
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/after/datasets/data_2_22.sexpr b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_22.sexpr
new file mode 100644
index 00000000..bd2f4f24
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/datasets/data_2_22.sexpr
@@ -0,0 +1,176772 @@
+(
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
+)
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/after/datasets/sexpr_sample.sexpr b/bench-version-changes/ghc-dps-compact/after/datasets/sexpr_sample.sexpr
new file mode 100644
index 00000000..db95e01d
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/after/datasets/sexpr_sample.sexpr
@@ -0,0 +1,22 @@
+(ert-deftest company-shows-keywords-alongside-completions-alphabetically ()
+  :tags '(company)
+  (switch-to-buffer "*TESTING COMPANY MODE ~ Python*")
+  (python-mode)
+
+  
+  (erase-buffer)
+  (insert "\n def first(x): pass")
+  (insert "\n def fierce(a, b): pass")
+
+  
+  (insert "\n fi")
+  (company-manual-begin)
+  (should (equal company-candidates '("fierce" "first" #("finally" 0 7 (company-backend company-keywords)))))
+
+  
+  (execute-kbd-macro (kbd "C-g C-/ M-2")) 
+  (should (looking-back "finally"))
+
+  (kill-buffer))
+
+
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact.hs
new file mode 100644
index 00000000..38143860
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact.hs
@@ -0,0 +1,9 @@
+module Bench.Compact where
+
+import Test.Tasty.Bench
+
+benchmarks :: Benchmark
+benchmarks =
+  bgroup
+    "DPS interface for compact regions (unsupported in this GHC version)"
+    []
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact/BFTraversal.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/BFTraversal.hs
new file mode 100644
index 00000000..72c79f1f
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/BFTraversal.hs
@@ -0,0 +1 @@
+module Bench.Compact.BFTraversal () where
\ No newline at end of file
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact/DList.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/DList.hs
new file mode 100644
index 00000000..1932d0ef
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/DList.hs
@@ -0,0 +1 @@
+module Bench.Compact.DList () where
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Map.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Map.hs
new file mode 100644
index 00000000..e5ee4ed4
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Map.hs
@@ -0,0 +1 @@
+module Bench.Compact.Map () where
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Queue.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Queue.hs
new file mode 100644
index 00000000..e953043c
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Queue.hs
@@ -0,0 +1 @@
+module Bench.Compact.Queue () where
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact/SExpr.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/SExpr.hs
new file mode 100644
index 00000000..a3449811
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/SExpr.hs
@@ -0,0 +1 @@
+module Bench.Compact.SExpr () where
diff --git a/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Utils.hs b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Utils.hs
new file mode 100644
index 00000000..db7f8246
--- /dev/null
+++ b/bench-version-changes/ghc-dps-compact/before/Bench/Compact/Utils.hs
@@ -0,0 +1 @@
+module Bench.Compact.Utils () where
diff --git a/bench/Main.hs b/bench/Main.hs
index f31d0d01..ed86b91f 100644
--- a/bench/Main.hs
+++ b/bench/Main.hs
@@ -3,6 +3,7 @@ module Main where
 import qualified Bench.Data.Array.Mutable as Array
 import qualified Bench.Data.Array.Mutable.Quicksort as Quicksort
 import qualified Bench.Data.HashMap.Mutable as HashMap
+import qualified Bench.Compact as Compact
 import Test.Tasty.Bench (defaultMain)
 
 main :: IO ()
@@ -10,5 +11,6 @@ main = do
   defaultMain
     [ Array.benchmarks,
       Quicksort.benchmarks,
-      HashMap.benchmarks
+      HashMap.benchmarks,
+      Compact.benchmarks
     ]
diff --git a/examples-version-changes/ghc-dps-compact/after/Compact/BFTraversal.hs b/examples-version-changes/ghc-dps-compact/after/Compact/BFTraversal.hs
new file mode 100644
index 00000000..eb4192ab
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/after/Compact/BFTraversal.hs
@@ -0,0 +1,115 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE UnicodeSyntax #-}
+{-# LANGUAGE GADTs #-}
+{-# OPTIONS_GHC -Wno-name-shadowing #-}
+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
+
+module Compact.BFTraversal where
+
+import Compact.Destination
+import Control.Functor.Linear ((<&>))
+import GHC.Generics
+import Prelude.Linear
+import Bench.Queue hiding (dataSets, impls)
+import Data.Proxy (Proxy)
+import Control.DeepSeq (NFData)
+import qualified Prelude as NonLin
+import qualified Data.Functor as NonLin
+import Prelude (Functor, fmap, Applicative, pure, (<*>), return)
+import Control.Exception (evaluate)
+import Control.DeepSeq (force)
+import Control.Monad.State.Lazy (runState, state)
+
+data BinTree a where
+  Nil :: BinTree a
+  Node :: a %1 -> (BinTree a) %1 -> (BinTree a) %1 -> BinTree a deriving (NonLin.Eq, Generic, NonLin.Show, NFData)
+
+pattern Leaf :: forall {a}. a -> BinTree a
+pattern Leaf x = Node x Nil Nil
+
+-- From "Phases in Software Architecture", Gibbons & al. 2023
+--------------------------------------------------------------------------------
+
+(⊗) :: Applicative m => m a -> m b -> m (a, b)
+xs ⊗ ys = pure (,) <*> xs <*> ys
+
+data Phases m a where
+  Pure :: a → Phases m a
+  Link :: (a → b → c) → m a → Phases m b → Phases m c
+
+instance Functor (Phases m) where
+  fmap f (Pure x) = Pure (f x)
+  fmap f (Link g mx my) = Link (\x y -> f (g x y)) mx my
+
+instance Applicative m ⇒ Applicative (Phases m) where
+  pure x = Pure x
+  Pure f <*> xs = NonLin.fmap f xs
+  fs <*> Pure x = NonLin.fmap (\f → f x) fs
+  Link f xs ys <*> Link g zs ws = Link h (xs ⊗ zs) (ys ⊗ ws) where h (x, z) (y, w) = (f x y) (g z w)
+
+now :: Applicative m ⇒ m a → Phases m a
+now xs = Link (curry fst) xs (Pure ())
+
+later :: Applicative m ⇒ Phases m a → Phases m a
+later xs = Link (curry snd) (pure ()) xs
+
+phase :: Applicative m ⇒ Int → m a → Phases m a
+phase 1 = now
+phase i = later NonLin.. phase (i - 1)
+
+runPhases :: Applicative m ⇒ Phases m a → m a
+runPhases (Pure x) = pure x
+runPhases (Link f xs ys) = pure f <*> xs <*> runPhases ys
+
+bft' :: Applicative m ⇒ (a → m b) → BinTree a → Phases m (BinTree b)
+bft' _ Nil = pure Nil
+bft' f (Node x tl tr) = pure Node <*> now (f x) <*> later ((bft' f) tl) <*> later ((bft' f) tr)
+
+mapPhasesBFS :: Applicative m ⇒ (a → m b) → BinTree a → m (BinTree b)
+mapPhasesBFS f = runPhases NonLin.. bft' f
+
+--------------------------------------------------------------------------------
+
+mapAccumBFS :: forall a b s. (s -> a -> (s, b)) -> s -> BinTree a -> (BinTree b, s)
+mapAccumBFS f s0 tree =
+  unur . withRegion $
+    \(_ :: Proxy r) token -> fromIncomplete $ alloc @r token <&>
+      \dtree -> go s0 (singletonN (Ur tree, dtree))
+  where
+    go :: forall r. (Region r) => s -> NaiveQueue (Ur (BinTree a), Dest r (BinTree b)) %1 -> Ur s
+    go s q = case dequeueN q of
+      Nothing -> Ur s
+      Just ((utree, dtree), q') -> case utree of
+        Ur Nil -> dtree & fill @'Nil `lseq` go s q'
+        Ur (Node x tl tr) -> case dtree & fill @'Node of
+          (dr, dtl, dtr) ->
+            let q'' = q' `enqueueN` (Ur tl, dtl) `enqueueN` (Ur tr, dtr)
+                (s', r) = f s x
+             in dr & fillLeaf r `lseq` go s' q''
+
+--------------------------------------------------------------------------------
+
+dpsRelabel :: BinTree () -> (BinTree Int, Int)
+dpsRelabel base = mapAccumBFS (\s _ -> (s + 1, s)) 0 base
+
+phasesRelabel :: BinTree () -> (BinTree Int, Int)
+phasesRelabel base = runState (mapPhasesBFS (\_ -> state (\s -> (s, s + 1))) base) 0
+
+impls :: [(BinTree () -> (BinTree Int, Int), String, Bool)]
+impls =
+  [ (dpsRelabel, "dpsRelabel", False)
+  , (phasesRelabel, "phasesRelabel", True)
+  ]
diff --git a/examples-version-changes/ghc-dps-compact/after/Compact/DList.hs b/examples-version-changes/ghc-dps-compact/after/Compact/DList.hs
new file mode 100644
index 00000000..86928cb1
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/after/Compact/DList.hs
@@ -0,0 +1,100 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# OPTIONS_GHC -Wno-name-shadowing -Wno-type-defaults #-}
+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
+
+module Compact.DList where
+
+import Compact.Destination
+import Control.Functor.Linear ((<&>))
+import Prelude.Linear hiding (foldl', foldr, concat)
+import Data.Proxy (Proxy)
+import qualified Prelude as NonLin
+
+newtype DList r a = DList (Incomplete r [a] (Dest r [a]))
+
+new :: forall r a. (Region r) => Token %1 -> DList r a
+new token = DList (alloc @r token)
+
+append :: forall r a. (Region r) => DList r a %1 -> a -> DList r a
+append (DList i) x =
+  DList $ i <&> \dl -> case dl & fill @'(:) of
+    (dh, dt) -> dh & fillLeaf x `lseq` dt
+
+concat :: forall r a. (Region r) => DList r a %1 -> DList r a %1 -> DList r a
+concat (DList i1) (DList i2) = DList $ i1 <&> \dl -> dl & fillComp i2
+
+toList :: forall r a. (Region r) => DList r a %1 -> [a]
+toList (DList i) = unur $ fromIncomplete_ $ i <&> \dl -> dl & fill @'[]
+
+toUList :: forall r a. (Region r) => DList r a %1 -> Ur [a]
+toUList (DList i) = fromIncomplete_ $ i <&> \dl -> dl & fill @'[]
+
+fromList :: forall r a. (Region r) => Token %1 -> [a] -> DList r a
+fromList token l = DList (alloc @r token <&> \d -> go d l) where
+  go dl [] = dl
+  go dl (x:xs) = case dl & fill @'(:) of (dh, dt) -> dh & fillLeaf x `lseq` go dt xs
+
+newtype DListN a = DListN ([a] %1 -> [a])
+
+newN :: forall a. DListN a
+newN = DListN (\ys -> ys)
+
+appendN :: forall a. DListN a %1 -> a %1 -> DListN a
+appendN (DListN f) x =
+  DListN $ \ys -> f ([x] ++ ys)
+
+concatN :: forall a. DListN a %1 -> DListN a %1 -> DListN a
+concatN (DListN f1) (DListN f2) = DListN $ f1 . f2
+
+toListN :: forall a. DListN a %1 -> [a]
+toListN (DListN f) = f []
+
+fromListN :: forall a. [a] %1 -> DListN a
+fromListN xs = DListN $ \ys -> xs ++ ys
+
+-------------------------------------------------------------------------------
+
+impls :: [([[Int]] -> [Int], String, Bool)]
+impls =
+  [ (concatRight, "concatRight", True)
+  , (differenceListNaiveLeft, "differenceListNaiveLeft", True)
+  , (differenceListDestLeft, "differenceListDestLeft", False)
+  ]
+
+foldl' :: forall a b. (a %1 -> b -> a) -> a %1 -> [b] -> a
+foldl' _ s [] = s
+foldl' f s (x : xs) = let !r = (f s x) in foldl' f r xs
+
+foldr :: forall a b. (b -> a %1 -> a) -> a %1 -> [b] -> a
+foldr _ s [] = s
+foldr f s (x : xs) = x `f` foldr f s xs
+
+concatLeft :: [[a]] -> [a]
+concatLeft = foldl' (\xs ys -> xs ++ ys) []
+
+concatRight :: [[a]] -> [a]
+concatRight = foldr (\xs ys -> xs ++ ys) []
+
+differenceListNaiveLeft :: [[a]] -> [a]
+differenceListNaiveLeft lists = toListN (foldl' (\dl ys -> let !r = dl `concatN` (fromListN ys) in r) newN lists)
+
+differenceListDestLeft :: [[a]] -> [a]
+differenceListDestLeft lists = unur (withRegion (\(_ :: Proxy r) t ->
+  let f :: (Token, DList r a) %1 -> [a] -> (Token, DList r a)
+      f (t, dl) ys =
+        let !(t', t'') = dup2 t
+            !r = dl `concat` (fromList @r t' ys)
+         in (t'', r)
+      !(t', t'') = dup2 t
+      !(t''', dl) = foldl' f (t'', new @r t') lists
+   in consume t''' `lseq` toUList dl ))
diff --git a/examples-version-changes/ghc-dps-compact/after/Compact/Map.hs b/examples-version-changes/ghc-dps-compact/after/Compact/Map.hs
new file mode 100644
index 00000000..1e22625e
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/after/Compact/Map.hs
@@ -0,0 +1,153 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE TupleSections #-}
+{-# OPTIONS_GHC -Wno-name-shadowing -Wno-type-defaults #-}
+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
+
+module Compact.Map where
+
+import Compact.Destination
+import Data.Kind (Type)
+import Prelude.Linear
+import Control.Functor.Linear ((<&>))
+import Data.Proxy (Proxy)
+import Control.DeepSeq (force)
+import Control.Exception (evaluate)
+import Prelude ((<$>))
+
+mapL :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapL _ [] = []
+mapL f (x : xs) = (f x) : (mapL f xs)
+
+mapS :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapS _ [] = []
+mapS f (x : xs) =
+  let !r = f x
+      !tail = mapS f xs
+   in r : tail
+
+mapSH :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapSH _ [] = []
+mapSH f (x : xs) =
+  let !r = f x
+   in r : (mapSH f xs)
+
+mapST :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapST _ [] = []
+mapST f (x : xs) =
+  let !tail = mapST f xs
+   in (f x) : tail
+
+mapTRL :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapTRL f = go []
+  where
+    go acc [] = reverse acc
+    go acc (x : xs) = go ((f x) : acc) xs
+
+mapTRS :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapTRS f = go []
+  where
+    go acc [] = reverse acc
+    go acc (x : xs) =
+      let !r = f x
+          !cons = r : acc
+       in go cons xs
+
+mapTRSH :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapTRSH f = go []
+  where
+    go acc [] = reverse acc
+    go acc (x : xs) =
+      let !r = f x
+       in go (r : acc) xs
+
+mapTRST :: forall a b. (a %1 -> b) -> [a] -> [b]
+mapTRST f = go []
+  where
+    go acc [] = reverse acc
+    go acc (x : xs) =
+      let !cons = (f x) : acc
+       in go cons xs
+
+mapDestTRL :: forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()
+mapDestTRL _ [] dl = dl & fill @'[]
+mapDestTRL f (x : xs) dl = case dl & fill @'(:) of
+  (dh, dt) -> dh & fillLeaf (f x) `lseq` mapDestTRL f xs dt
+
+mapDestTRS :: forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()
+mapDestTRS _ [] dl = dl & fill @'[]
+mapDestTRS f (x : xs) dl = case dl & fill @'(:) of
+  (dh, dt) -> let !r = f x in dh & fillLeaf r `lseq` mapDestTRS f xs dt
+
+mapDestFL :: forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()
+mapDestFL f l dl =
+  (foldl_ fillConsF dl l) & fill @'[]
+  where
+    fillConsF :: Dest r [b] %1 -> a -> Dest r [b]
+    fillConsF dl x = case dl & fill @'(:) of
+      (dh, dt) -> dh & fillLeaf (f x) `lseq` dt
+    foldl_ :: forall a b. (a %1 -> b -> a) -> a %1 -> [b] -> a
+    foldl_ _ s [] = s
+    foldl_ f s (x : xs) = foldl_ f (f s x) xs
+
+mapDestFSL :: forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()
+mapDestFSL f l dl =
+  (foldl_ fillConsF dl l) & fill @'[]
+  where
+    fillConsF dl x = case dl & fill @'(:) of
+      (dh, dt) -> dh & fillLeaf (f x) `lseq` dt
+    foldl_ :: forall a b. (a %1 -> b -> a) -> a %1 -> [b] -> a
+    foldl_ _ s [] = s
+    foldl_ f s (x : xs) = let !r = (f s x) in foldl_ f r xs
+
+mapDestFLS :: forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()
+mapDestFLS f l dl =
+  (foldl_ fillConsF dl l) & fill @'[]
+  where
+    fillConsF dl x = case dl & fill @'(:) of
+      (dh, dt) -> let !r = f x in dh & fillLeaf r `lseq` dt
+    foldl_ :: forall a b. (a %1 -> b -> a) -> a %1 -> [b] -> a
+    foldl_ _ s [] = s
+    foldl_ f s (x : xs) = foldl_ f (f s x) xs
+
+mapDestFS :: forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()
+mapDestFS f l dl =
+  (foldl_ fillConsF dl l) & fill @'[]
+  where
+    fillConsF dl x = case dl & fill @'(:) of
+      (dh, dt) -> let !r = f x in dh & fillLeaf r `lseq` dt
+    foldl_ :: forall a b. (a %1 -> b -> a) -> a %1 -> [b] -> a
+    foldl_ _ s [] = s
+    foldl_ f s (x : xs) = let !r = (f s x) in foldl_ f r xs
+
+-------------------------------------------------------------------------------
+
+uncurryDest :: (forall (r :: Type) a b. (Region r) => (a %1 -> b) -> [a] -> Dest r [b] %1 -> ()) -> ((Int %1 -> Int, [Int]) -> [Int])
+uncurryDest impl (f, l) = unur (withRegion (\(_ :: Proxy r) t -> fromIncomplete_ (alloc @r t <&> \d -> impl f l d)))
+
+impls :: [((Int %1 -> Int, [Int]) -> [Int], String, Bool)]
+impls =
+  [ (uncurry mapL, "mapL", True),
+    (uncurry mapS, "mapS", True),
+    (uncurry mapSH, "mapSH", True),
+    (uncurry mapST, "mapST", True),
+    (uncurry mapTRL, "mapTRL", True),
+    (uncurry mapTRS, "mapTRS", True),
+    (uncurry mapTRSH, "mapTRSH", True),
+    (uncurry mapTRST, "mapTRST", True),
+    (uncurryDest mapDestTRL, "mapDestTRL", False),
+    (uncurryDest mapDestTRS, "mapDestTRS", False),
+    (uncurryDest mapDestFL, "mapDestFL", False),
+    (uncurryDest mapDestFLS, "mapDestFLS", False),
+    (uncurryDest mapDestFSL, "mapDestFSL", False),
+    (uncurryDest mapDestFS, "mapDestFS", False)
+  ]
diff --git a/examples-version-changes/ghc-dps-compact/after/Compact/Queue.hs b/examples-version-changes/ghc-dps-compact/after/Compact/Queue.hs
new file mode 100644
index 00000000..7976f754
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/after/Compact/Queue.hs
@@ -0,0 +1,126 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# OPTIONS_GHC -Wno-name-shadowing -Wno-type-defaults #-}
+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
+
+module Compact.Queue where
+
+import Compact.Destination
+import qualified Bench.DList as DList
+import Bench.DList
+import Prelude.Linear hiding ((+), (*), (<))
+import Prelude (return, (+), (*), (<))
+import Data.Word
+import Data.Proxy (Proxy)
+
+data NaiveQueue a = NaiveQueue [a] [a]
+
+newN :: NaiveQueue a
+newN = NaiveQueue [] []
+
+singletonN :: a %1 -> NaiveQueue a
+singletonN x = NaiveQueue [x] []
+
+toListN :: NaiveQueue a %1 -> [a]
+toListN (NaiveQueue l r) = l ++ reverse r
+
+enqueueN :: NaiveQueue a %1 -> a %1 -> NaiveQueue a
+enqueueN (NaiveQueue l r) x = NaiveQueue l (x : r)
+
+dequeueN :: NaiveQueue a %1 -> Maybe (a, NaiveQueue a)
+dequeueN (NaiveQueue l r) = case l of
+  [] -> case reverse r of
+    [] -> Nothing
+    (x : xs) -> Just (x, NaiveQueue xs [])
+  (x : xs) -> Just (x, NaiveQueue xs r)
+
+data QueueF a = QueueF [a] (DListN a)
+
+newF :: forall a. QueueF a
+newF = QueueF [] DList.newN
+
+singletonF :: forall a. a %1 -> QueueF a
+singletonF x = QueueF [x] DList.newN
+
+toListF :: forall a. QueueF a %1 -> [a]
+toListF (QueueF l dl) = l ++ DList.toListN dl
+
+enqueueF :: forall a. QueueF a %1 -> a %1 -> QueueF a
+enqueueF (QueueF l dl) x = QueueF l (DList.appendN dl x)
+
+dequeueF :: forall a. QueueF a %1 -> Maybe (a, QueueF a)
+dequeueF (QueueF l dl) = case l of
+  [] -> case DList.toListN dl of
+    [] -> Nothing
+    (x : xs) -> Just (x, QueueF xs DList.newN)
+  (x : xs) -> Just (x, QueueF xs dl)
+
+data Queue r a = Queue [a] (DList r a)
+
+new :: forall r a. (Region r) => Token %1 -> Queue r a
+new token = Queue [] (DList.new @r token)
+
+singleton :: forall r a. (Region r) => Token %1 -> a -> Queue r a
+singleton token x = Queue [x] (DList.new @r token)
+
+toList :: forall r a. (Region r) => Queue r a %1 -> [a]
+toList (Queue l dl) = l ++ DList.toList dl
+
+enqueue :: forall r a. (Region r) => Queue r a %1 -> a -> Queue r a
+enqueue (Queue l dl) x = Queue l (DList.append dl x)
+
+dequeue :: forall r a. (Region r) => Queue r a %1 -> Maybe (a, Queue r a)
+dequeue (Queue l (DList i)) = case l of
+  [] -> let !(i', token) = piggyback i in case DList.toList (DList i') of
+    [] -> consume token `lseq` Nothing
+    (x : xs) -> Just (x, Queue xs (DList.new @r token))
+  (x : xs) -> Just (x, Queue xs (DList i))
+
+-------------------------------------------------------------------------------
+
+naiveImpl :: Word64 -> Word64
+naiveImpl limit = go 0 (singletonN 1)
+  where
+    go sum q = case dequeueN q of
+      Nothing -> sum
+      Just (x, q') -> go (sum + x) q'' where
+        q'' = if x < limit
+                then q' `enqueueN` (2 * x) `enqueueN` (2 * x + 1)
+                else q'
+
+funcImpl :: Word64 -> Word64
+funcImpl limit = go 0 (singletonF 1)
+  where
+    go sum q = case dequeueF q of
+      Nothing -> sum
+      Just (x, q') -> go (sum + x) q'' where
+        q'' = if x < limit
+                then q' `enqueueF` (2 * x) `enqueueF` (2 * x + 1)
+                else q'
+
+destImpl :: Word64 -> Word64
+destImpl limit = unur (withRegion (\(_ :: Proxy r) t -> let r = go 0 (singleton @r t (Ur 1)) in move r))
+  where
+    go :: Region r => Word64 -> Queue r (Ur Word64) %1 -> Word64
+    go sum q = case dequeue q of
+      Nothing -> sum
+      Just (Ur x, q') -> go (sum + x) q'' where
+        q'' = if x < limit
+                then q' `enqueue` Ur (2 * x) `enqueue` Ur (2 * x + 1)
+                else q'
+
+impls :: [(Word64 -> Word64, String, Bool)]
+impls =
+  [ (naiveImpl, "naiveImpl", False)
+  , (funcImpl, "funcImpl", False)
+  , (destImpl, "destImpl", False)
+  ]
diff --git a/examples-version-changes/ghc-dps-compact/after/Compact/SExpr.hs b/examples-version-changes/ghc-dps-compact/after/Compact/SExpr.hs
new file mode 100644
index 00000000..6bef5a15
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/after/Compact/SExpr.hs
@@ -0,0 +1,232 @@
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE MultiWayIf #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# OPTIONS_GHC -Wno-name-shadowing #-}
+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
+
+module Compact.SExpr where
+
+import Compact.Destination.Internal
+import Control.DeepSeq (NFData, force)
+import Control.Exception (evaluate)
+import Control.Functor.Linear ((<&>))
+import Data.ByteString.Char8 (ByteString)
+import qualified Data.ByteString.Char8 as BSC
+import Data.Char (isSpace)
+import GHC.Generics (Generic)
+import Prelude.Linear
+import Data.Proxy (Proxy)
+import qualified Prelude as NonLinear
+
+data SExpr
+  = SList Int [SExpr]
+  | SInteger Int Int
+  | SString Int String
+  | SSymbol Int String
+  deriving (NonLinear.Eq, Generic, NFData)
+
+{-# INLINE endPos #-}
+endPos :: SExpr -> Int
+endPos = \case
+  SList n _ -> n
+  SInteger n _ -> n
+  SString n _ -> n
+  SSymbol n _ -> n
+
+showSExpr :: Bool -> Int -> SExpr -> String
+showSExpr cont indent = \case
+  SList _ [] -> makeIndent cont indent ++ "()"
+  SList _ (x : xs) ->
+    makeIndent cont indent
+      ++ "("
+      ++ showSExpr True (indent + 1) x
+      ++ NonLinear.concatMap (\x' -> "\n" ++ showSExpr False (indent + 1) x') xs
+      ++ ")"
+  SInteger _ i -> makeIndent cont indent ++ show i
+  SString _ s -> makeIndent cont indent ++ show s
+  SSymbol _ s -> makeIndent cont indent ++ s
+  where
+    makeIndent isCont n = if isCont then "" else replicate n ' '
+
+instance Show SExpr where
+  show x = showSExpr False 0 x
+
+data SExprParseError
+  = UnexpectedClosingParen Int
+  | UnexpectedEOFSExpr Int
+  | UnexpectedEOFSList Int
+  | UnexpectedEOFSString Int
+  | UnexpectedContentAfter Int
+  deriving (NonLinear.Eq, Generic, NFData)
+
+errEndPos :: SExprParseError -> Int
+errEndPos = \case
+  UnexpectedClosingParen n -> n
+  UnexpectedEOFSExpr n -> n
+  UnexpectedEOFSList n -> n
+  UnexpectedEOFSString n -> n
+  UnexpectedContentAfter n -> n
+
+instance Consumable SExprParseError where
+  consume = \case
+    UnexpectedClosingParen n -> consume n
+    UnexpectedEOFSExpr n -> consume n
+    UnexpectedEOFSList n -> consume n
+    UnexpectedEOFSString n -> consume n
+    UnexpectedContentAfter n -> consume n
+
+instance Dupable SExprParseError where
+  dup2 = \case
+    UnexpectedClosingParen n -> let !(n1, n2) = dup2 n in (UnexpectedClosingParen n1, UnexpectedClosingParen n2)
+    UnexpectedEOFSExpr n -> let !(n1, n2) = dup2 n in (UnexpectedEOFSExpr n1, UnexpectedEOFSExpr n2)
+    UnexpectedEOFSList n -> let !(n1, n2) = dup2 n in (UnexpectedEOFSList n1, UnexpectedEOFSList n2)
+    UnexpectedEOFSString n -> let !(n1, n2) = dup2 n in (UnexpectedEOFSString n1, UnexpectedEOFSString n2)
+    UnexpectedContentAfter n -> let !(n1, n2) = dup2 n in (UnexpectedContentAfter n1, UnexpectedContentAfter n2)
+
+instance Movable SExprParseError where
+  move = \case
+    UnexpectedClosingParen n -> let !(Ur n') = move n in Ur (UnexpectedClosingParen n')
+    UnexpectedEOFSExpr n -> let !(Ur n') = move n in Ur (UnexpectedEOFSExpr n')
+    UnexpectedEOFSList n -> let !(Ur n') = move n in Ur (UnexpectedEOFSList n')
+    UnexpectedEOFSString n -> let !(Ur n') = move n in Ur (UnexpectedEOFSString n')
+    UnexpectedContentAfter n -> let !(Ur n') = move n in Ur (UnexpectedContentAfter n')
+
+instance Show SExprParseError where
+  show = \case
+    UnexpectedClosingParen n -> "Parse error: Encountered an unexpected closing parentheses at position " ++ show n
+    UnexpectedEOFSExpr n -> "Parse error: Ecountered EOF while expecting an SExpr at position " ++ show n
+    UnexpectedEOFSList n -> "Parse error: Encountered EOF in the middle of parsing an SList at position " ++ show n
+    UnexpectedEOFSString n -> "Parse error: Encountered EOF in the middle of parsing a quoted string at position " ++ show n
+    UnexpectedContentAfter n -> "Parse error: Encountered unexpected content after the SExpr at position " ++ show n
+
+defaultSExpr :: SExpr
+defaultSExpr = SInteger (-1) 0
+
+extractNextToken :: ByteString -> Int -> ByteString
+extractNextToken bs i = fst $ BSC.span (\c -> not (isSpace c) && c /= '(' && c /= ')' && c /= '"') (snd $ BSC.splitAt i bs)
+
+parseStringWithoutDest' :: ByteString -> Int -> Bool -> [Char] -> Either SExprParseError SExpr
+parseStringWithoutDest' bs i escape acc = case bs BSC.!? i of
+  Nothing -> Left $ UnexpectedEOFSString i
+  Just c -> case c of
+    '"' | not escape -> Right $ SString i (reverse acc)
+    '\\' | not escape -> parseStringWithoutDest' bs (i + 1) True acc
+    'n' | escape -> parseStringWithoutDest' bs (i + 1) False ('\n' : acc)
+    _ -> parseStringWithoutDest' bs (i + 1) False (c : acc)
+
+parseStringWithDest' :: (Region r) => ByteString -> Int -> Bool -> Dest r Int %1 -> Dest r [Char] %1 -> Either SExprParseError Int
+parseStringWithDest' bs i escape dEndPos d = case bs BSC.!? i of
+  Nothing -> dEndPos & fillLeaf (-1) `lseq` d & fill @'[] `lseq` Left $ UnexpectedEOFSString i
+  Just c -> case c of
+    '"' | not escape -> dEndPos & fillLeaf i `lseq` d & fill @'[] `lseq` Right i
+    '\\' | not escape -> parseStringWithDest' bs (i + 1) True dEndPos d
+    'n' | escape -> let !(dh, dt) = d & fill @'(:) in dh & fillLeaf '\n' `lseq` parseStringWithDest' bs (i + 1) False dEndPos dt
+    _ -> let !(dh, dt) = d & fill @'(:) in dh & fillLeaf c `lseq` parseStringWithDest' bs (i + 1) False dEndPos dt
+
+parseListWithoutDest' :: ByteString -> Int -> [SExpr] -> Either SExprParseError SExpr
+parseListWithoutDest' bs i acc = case bs BSC.!? i of
+  Nothing -> Left $ UnexpectedEOFSList i
+  Just c ->
+    \cases
+      | c == ')' -> Right $ SList i (reverse acc)
+      -- we need this case for final spaces before the closing paren
+      -- parseWithoutDest' know how to handle leading spaces, but will expect a token after, whereas this case allows for trailing spaces
+      | isSpace c -> parseListWithoutDest' bs (i + 1) acc
+      | otherwise -> case parseWithoutDest' bs i of
+          Left err -> Left err
+          Right children -> parseListWithoutDest' bs (endPos children + 1) (children : acc)
+
+parseListWithDest' :: (Region r) => ByteString -> Int -> Dest r Int %1 -> Dest r [SExpr] %1 -> Either SExprParseError Int
+parseListWithDest' bs i dEndPos d = case bs BSC.!? i of
+  Nothing -> dEndPos & fillLeaf (-1) `lseq` d & fill @'[] `lseq` Left $ UnexpectedEOFSList i
+  Just c ->
+    \cases
+      | c == ')' -> dEndPos & fillLeaf i `lseq` d & fill @'[] `lseq` Right i
+      -- we need this case for final spaces before the closing paren
+      -- parseWithoutDest' know how to handle leading spaces, but will expect a token after, whereas this case allows for trailing spaces
+      | isSpace c -> parseListWithDest' bs (i + 1) dEndPos d
+      | otherwise ->
+          let !(dh, dt) = d & fill @'(:)
+           in case parseWithDest' bs i dh of
+                Left err -> dEndPos & fillLeaf (-1) `lseq` dt & fill @'[] `lseq` Left err
+                Right childrenEndPos -> parseListWithDest' bs (childrenEndPos + 1) dEndPos dt
+
+parseWithoutDest' :: ByteString -> Int -> Either SExprParseError SExpr
+parseWithoutDest' bs i = case bs BSC.!? i of
+  Nothing -> Left $ UnexpectedEOFSExpr i
+  Just c -> case c of
+    ')' -> Left $ UnexpectedClosingParen i
+    '(' -> parseListWithoutDest' bs (i + 1) []
+    '"' -> parseStringWithoutDest' bs (i + 1) False []
+    _ ->
+      let token = extractNextToken bs i
+       in if BSC.null token
+            then -- c is a (leading) space because we matched against the other cases before
+              parseWithoutDest' bs (i + 1)
+            else case BSC.readInt token of
+              Just (int, remaining) | BSC.null remaining -> Right $ SInteger (i + BSC.length token - 1) int
+              _ -> Right $ SSymbol (i + BSC.length token - 1) (BSC.unpack token)
+
+parseWithDest' :: (Region r) => ByteString -> Int -> Dest r SExpr %1 -> Either SExprParseError Int
+parseWithDest' bs i d = case bs BSC.!? i of
+  Nothing -> d & fillLeaf defaultSExpr `lseq` Left $ UnexpectedEOFSExpr i
+  Just c -> case c of
+    ')' -> d & fillLeaf defaultSExpr `lseq` Left $ UnexpectedClosingParen i
+    '(' -> let !(dEndPos, dList) = d & fill @'SList in parseListWithDest' bs (i + 1) dEndPos dList
+    '"' -> let !(dEndPos, dStr) = d & fill @'SString in parseStringWithDest' bs (i + 1) False dEndPos dStr
+    _ ->
+      let token = extractNextToken bs i
+       in if BSC.null token
+            then -- c is a (leading) space because we matched against the other cases before
+              parseWithDest' bs (i + 1) d
+            else case BSC.readInt token of
+              Just (int, remaining)
+                | BSC.null remaining ->
+                    let !(dEndPos, dInt) = d & fill @'SInteger
+                        endPos = i + BSC.length token - 1
+                     in dEndPos & fillLeaf endPos `lseq` dInt & fillLeaf int `lseq` Right endPos
+              _ ->
+                let !(dEndPos, dSym) = d & fill @'SSymbol
+                    endPos = i + BSC.length token - 1
+                 in dEndPos & fillLeaf endPos `lseq` dSym & fillLeaf (BSC.unpack token) `lseq` Right endPos
+
+parseWithoutDest :: ByteString -> Either SExprParseError SExpr
+parseWithoutDest bs = case parseWithoutDest' bs 0 of
+  Left err -> Left err
+  Right sexpr ->
+    let i = endPos sexpr
+     in if
+          | i >= BSC.length bs - 1 -> Right sexpr
+          | rem <- snd (BSC.splitAt (i + 1) bs), BSC.all isSpace rem -> Right sexpr
+          | otherwise -> Left $ UnexpectedContentAfter (i + 1)
+
+parseWithDest :: ByteString -> Either SExprParseError SExpr
+parseWithDest bs =
+  let Ur (sexpr, res) =
+        withRegion $ \(_ :: Proxy r) token ->
+          fromIncomplete
+            $ alloc @r token
+            <&> \d ->
+              move $ parseWithDest' bs 0 d
+   in case res of
+        Left err -> Left err
+        Right i ->
+          if
+            | i >= BSC.length bs - 1 -> Right sexpr
+            | rem <- snd (BSC.splitAt (i + 1) bs), BSC.all isSpace rem -> Right sexpr
+            | otherwise -> Left $ UnexpectedContentAfter (i + 1)
+
+impls :: [(ByteString -> Either SExprParseError SExpr, String, Bool)]
+impls =
+  [ (parseWithoutDest, "parseWithoutDest", True)
+  , (parseWithDest, "parseWithDest", False)
+  ]
\ No newline at end of file
diff --git a/examples-version-changes/ghc-dps-compact/before/Compact/BFTraversal.hs b/examples-version-changes/ghc-dps-compact/before/Compact/BFTraversal.hs
new file mode 100644
index 00000000..59567e3d
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/before/Compact/BFTraversal.hs
@@ -0,0 +1 @@
+module Compact.BFTraversal () where
diff --git a/examples-version-changes/ghc-dps-compact/before/Compact/DList.hs b/examples-version-changes/ghc-dps-compact/before/Compact/DList.hs
new file mode 100644
index 00000000..414b5ba2
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/before/Compact/DList.hs
@@ -0,0 +1 @@
+module Compact.DList () where
diff --git a/examples-version-changes/ghc-dps-compact/before/Compact/Map.hs b/examples-version-changes/ghc-dps-compact/before/Compact/Map.hs
new file mode 100644
index 00000000..6d7ef01d
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/before/Compact/Map.hs
@@ -0,0 +1 @@
+module Compact.Map () where
diff --git a/examples-version-changes/ghc-dps-compact/before/Compact/Queue.hs b/examples-version-changes/ghc-dps-compact/before/Compact/Queue.hs
new file mode 100644
index 00000000..d9dcf8d0
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/before/Compact/Queue.hs
@@ -0,0 +1 @@
+module Compact.Queue () where
diff --git a/examples-version-changes/ghc-dps-compact/before/Compact/SExpr.hs b/examples-version-changes/ghc-dps-compact/before/Compact/SExpr.hs
new file mode 100644
index 00000000..f81ea50e
--- /dev/null
+++ b/examples-version-changes/ghc-dps-compact/before/Compact/SExpr.hs
@@ -0,0 +1 @@
+module Compact.SExpr () where
diff --git a/examples/README.md b/examples/README.md
index 3e6e99fd..27f920a5 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -10,3 +10,7 @@
  * `Foreign`
    * These are examples of explicitly allocating off the GC heap's
    memory and on the system heap's memory.
+ * `Compact`
+   * These are examples of using compact regions through the
+   destination-passing style interface.
+
diff --git a/ghc-dps-compact-702220602b.tar.xz b/ghc-dps-compact-702220602b.tar.xz
new file mode 100644
index 00000000..b2726bc6
--- /dev/null
+++ b/ghc-dps-compact-702220602b.tar.xz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a9c8d8defb90b9f0f2df68bd31c4c2750d153700e72a99c946a5109a9313f27
+size 1131516172
diff --git a/linear-base.cabal b/linear-base.cabal
index e57d013b..71a9cdff 100644
--- a/linear-base.cabal
+++ b/linear-base.cabal
@@ -41,7 +41,13 @@ library
         hs-source-dirs: src-version-changes/ghc96/after
     else
         hs-source-dirs: src-version-changes/ghc96/before
+    if impl(ghc == 9.11.0)
+        hs-source-dirs: src-version-changes/ghc-dps-compact/after
+    else
+        hs-source-dirs: src-version-changes/ghc-dps-compact/before
     exposed-modules:
+        Compact.Destination
+        Compact.Destination.Internal
         Control.Monad.IO.Class.Linear
         Control.Functor.Linear
         Control.Functor.Linear.Internal.Class
@@ -135,6 +141,7 @@ library
     build-depends:
         base >=4.16 && <5,
         containers,
+        ghc-compact,
         ghc-prim,
         ghc-bignum,
         hashable,
@@ -148,6 +155,10 @@ library
 library examples
     import: build-opts
     hs-source-dirs: examples
+    if impl(ghc == 9.11.0)
+        hs-source-dirs: examples-version-changes/ghc-dps-compact/after
+    else
+        hs-source-dirs: examples-version-changes/ghc-dps-compact/before
     exposed-modules:
         Foreign.List
         Foreign.Heap
@@ -155,8 +166,14 @@ library examples
         Simple.Pure
         Data.Array.Mutable.Quicksort
         Data.HashMap.Mutable.TopSort
+        Compact.BFTraversal
+        Compact.DList
+        Compact.Map
+        Compact.Queue
+        Compact.SExpr
     build-depends:
         base,
+        bytestring,
         linear-base,
         storable-tuple,
         vector,
@@ -168,6 +185,10 @@ test-suite test
     type:             exitcode-stdio-1.0
     main-is:          Main.hs
     hs-source-dirs:   test
+    if impl(ghc == 9.11.0)
+        hs-source-dirs: test-version-changes/ghc-dps-compact/after
+    else
+        hs-source-dirs: test-version-changes/ghc-dps-compact/before
     other-modules:
         Test.Data.Array.Destination
         Test.Data.Array.Mutable
@@ -178,6 +199,7 @@ test-suite test
         Test.Data.Functor.Linear
         Test.Data.V
         Test.Data.Replicator
+        Test.Compact.Destination
     default-language: Haskell2010
     build-depends:
         inspection-testing,
@@ -198,12 +220,24 @@ test-suite test-examples
     type:             exitcode-stdio-1.0
     main-is:          Main.hs
     hs-source-dirs:   test-examples
+    if impl(ghc == 9.11.0)
+        hs-source-dirs: test-examples-version-changes/ghc-dps-compact/after
+    else
+        hs-source-dirs: test-examples-version-changes/ghc-dps-compact/before
     other-modules:
         Test.Foreign
         Test.Data.Array.Mutable.Quicksort
+        Test.Compact.BFTraversal
+        Test.Compact.DList
+        Test.Compact.Map
+        Test.Compact.Queue
+        Test.Compact.SExpr
+        Test.Compact.Utils
+        Test.Compact
     default-language: Haskell2010
     build-depends:
         base,
+        bytestring,
         linear-base,
         tasty,
         tasty-hedgehog,
@@ -216,13 +250,25 @@ benchmark bench
     type:             exitcode-stdio-1.0
     main-is:          Main.hs
     hs-source-dirs:   bench
+    if impl(ghc == 9.11.0)
+        hs-source-dirs: bench-version-changes/ghc-dps-compact/after
+    else
+        hs-source-dirs: bench-version-changes/ghc-dps-compact/before
     other-modules:
         Bench.Data.HashMap.Mutable
         Bench.Data.Array.Mutable
         Bench.Data.Array.Mutable.Quicksort
+        Bench.Compact.BFTraversal
+        Bench.Compact.DList
+        Bench.Compact.Map
+        Bench.Compact.Queue
+        Bench.Compact.SExpr
+        Bench.Compact.Utils
+        Bench.Compact
     default-language: Haskell2010
     build-depends:
         base,
+        bytestring,
         containers,
         vector,
         deepseq,
diff --git a/src-version-changes/ghc-dps-compact/after/Compact/Destination.hs b/src-version-changes/ghc-dps-compact/after/Compact/Destination.hs
new file mode 100644
index 00000000..20e3b4ea
--- /dev/null
+++ b/src-version-changes/ghc-dps-compact/after/Compact/Destination.hs
@@ -0,0 +1,19 @@
+module Compact.Destination
+  ( Token,
+    Region,
+    withRegion,
+    Incomplete,
+    piggyback,
+    alloc,
+    intoIncomplete,
+    fromIncomplete_,
+    fromIncomplete,
+    Dest,
+    DestsOf,
+    fill,
+    fillComp,
+    fillLeaf
+  )
+where
+
+import Compact.Destination.Internal
diff --git a/src-version-changes/ghc-dps-compact/after/Compact/Destination/Internal.hs b/src-version-changes/ghc-dps-compact/after/Compact/Destination/Internal.hs
new file mode 100644
index 00000000..5fc65912
--- /dev/null
+++ b/src-version-changes/ghc-dps-compact/after/Compact/Destination/Internal.hs
@@ -0,0 +1,471 @@
+{-# LANGUAGE GHC2021 #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DerivingVia #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS_HADDOCK hide #-}
+
+module Compact.Destination.Internal where
+
+import Control.Functor.Linear (Data)
+import Control.Functor.Linear qualified as Control
+import Data.Data (Proxy (Proxy))
+import Data.Functor.Linear qualified as Data
+import Data.Kind (Type)
+import Data.List (intercalate)
+import Data.Reflection (Reifies (reflect), reify)
+import Data.Replicator.Linear.Internal (Replicator (Moved))
+import Data.Unrestricted.Linear.Internal.Consumable
+import Data.Unrestricted.Linear.Internal.Dupable
+import Data.Unrestricted.Linear.Internal.Ur
+import GHC.Compact (Compact (..), compact, getCompact)
+import GHC.Exts
+import GHC.Generics
+import GHC.IO (IO (..), unsafePerformIO)
+import GHC.MVar (MVar (..))
+import GHC.TypeLits
+import Unsafe.Coerce (unsafeCoerceAddr)
+import Unsafe.Linear (toLinear, toLinear2)
+import Prelude hiding (Monad, (>>=))
+
+debugEnabled :: Bool
+debugEnabled = False
+
+ptrToWord :: Ptr a -> Word
+ptrToWord (Ptr addr#) = W# (addr2Word# addr#)
+
+addr2Word# :: Addr# -> Word#
+addr2Word# addr# = int2Word# (addr2Int# addr#)
+
+word2Addr# :: Word# -> Addr#
+word2Addr# word# = int2Addr# (word2Int# word#)
+
+alignAddr# :: Addr# -> Addr#
+alignAddr# addr# =
+  let word# = int2Word# (addr2Int# addr#)
+      nmask# = int2Word# 7#
+      wordAligned# = word# `and#` (not# nmask#)
+   in int2Addr# (word2Int# wordAligned#)
+
+indInfoPtr :: Ptr Word
+indInfoPtr = Ptr (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# "IND"))
+
+showFill :: Ptr Word -> Ptr Word -> String -> [Ptr Word] -> String
+showFill parentWriteLoc pX ctorName slots =
+  "fill"
+    ++ (show n)
+    ++ ": @"
+    ++ show (ptrToWord parentWriteLoc)
+    ++ " <- #"
+    ++ show (ptrToWord pX)
+    ++ ": "
+    ++ ctorName
+    ++ " "
+    ++ showSlots slots
+  where
+    n = length slots
+    showSlots = intercalate " " . fmap showSlot
+    showSlot ptr = "_@" ++ (show $ ptrToWord ptr)
+
+putDebugLn :: String -> IO ()
+putDebugLn x =
+  if debugEnabled
+    then putStrLn x
+    else return ()
+{-# INLINE putDebugLn #-}
+
+putDebugLn# :: String -> (# State# RealWorld, res #) -> (# State# RealWorld, res #)
+putDebugLn# text (# s0, res #) =
+  if debugEnabled
+    then case (putStrLn text) of IO f -> case f s0 of (# s1, () #) -> (# s1, res #)
+    else (# s0, res #)
+{-# INLINE putDebugLn# #-}
+
+putInRegionIfNot# :: Compact# -> MVar# RealWorld () -> a -> State# RealWorld -> (# State# RealWorld, a #)
+putInRegionIfNot# c# m# x = \s0 -> case compactContains# c# x s0 of
+  (# s1, 1# #) -> (# s1, x #) -- already in region
+  (# s1, _ #) -> case takeMVar# m# s1 of
+    (# s2, () #) -> case compactAdd# c# x s2 of
+      (# s3, xInRegion #) -> case putMVar# m# () s3 of
+        s4 -> (# s4, xInRegion #)
+{-# INLINE putInRegionIfNot# #-}
+
+-- x must be already in the same region as the value, and fully evaluated
+affect# :: Addr# -> a -> State# RealWorld -> (# State# RealWorld, Addr# #)
+affect# dest xInRegion s0 = case anyToAddr# xInRegion s0 of
+  (# s1, pXInRegion# #) -> case writeAddrOffAddr# (unsafeCoerceAddr dest) 0# pXInRegion# s1 of
+    s2 -> (# s2, pXInRegion# #)
+{-# INLINE affect# #-}
+
+-------------------------------------------------------------------------------
+-- RegionInfo and dests
+-------------------------------------------------------------------------------
+
+data FirstInhabitant = FirstInhabitant Int
+
+firstInhabitant :: FirstInhabitant
+firstInhabitant = FirstInhabitant 1234
+
+newtype RegionInfo = RegionInfo (Compact FirstInhabitant)
+
+data Token = Token
+
+instance Consumable (Token) where
+  consume Token = ()
+
+instance Dupable (Token) where
+  dupR Token = Moved Token
+
+type Region r = Reifies r RegionInfo
+
+getRegionInfo :: forall r. Region r => RegionInfo
+getRegionInfo = reflect (Proxy :: Proxy r)
+{-# INLINE getRegionInfo #-}
+
+withRegion :: forall b. (forall (r :: Type). (Region r) => Proxy r -> Token %1 -> Ur b) %1 -> Ur b
+withRegion = toLinear _withRegion
+{-# INLINE withRegion #-}
+
+{-# NOINLINE _withRegion #-}
+_withRegion :: forall b. (forall (r :: Type). (Region r) => Proxy r -> Token %1 -> Ur b) -> Ur b
+_withRegion f =
+  unsafePerformIO $ do
+    c <- (compact firstInhabitant)
+    let !firstInhabitantInRegion = getCompact c
+    firstPtr <- IO (\s -> case anyToAddr# firstInhabitantInRegion s of (# s', addr# #) -> (# s', W# (addr2Word# addr#) #))
+    putDebugLn $
+      "withRegion: allocating new region around @"
+        ++ (show firstPtr)
+    return $! reify (RegionInfo c) (\(proxy :: Proxy s) -> f @s proxy Token)
+
+newtype Incomplete r a b = Incomplete (a, b)
+  deriving (Data.Functor) via Data (Incomplete r a)
+  deriving (Control.Functor)
+
+piggyback :: forall r a b. (Region r) => Incomplete r a b %1 -> (Incomplete r a b, Token)
+piggyback i = (i, Token)
+{-# INLINE piggyback #-}
+
+alloc :: forall r a. (Region r) => Token %1 -> Incomplete r a (Dest r a)
+alloc = toLinear _alloc
+
+{-# INLINE _alloc #-}
+_alloc :: forall r a. (Region r) => Token -> Incomplete r a (Dest r a)
+_alloc _ = case getRegionInfo @r of
+  RegionInfo (Compact c# _ (MVar m#)) -> case indInfoPtr of
+    Ptr indInfoAddr# -> case runRW# $ \s0 -> case takeMVar# m# s0 of
+      (# s1, () #) -> case compactAddShallow# @a c# indInfoAddr# s1 of
+        (# s2, indRoot #) -> case anyToAddr# indRoot s2 of
+          (# s3, pIndRoot# #) -> case getSlots1# indRoot s3 of
+            (# s4, (# dRoot# #) #) -> case putMVar# m# () s4 of
+              s5 -> putDebugLn# message (# s5, Incomplete (indRoot, Dest dRoot#) #)
+                where
+                  message =
+                    ( "alloc: [region] <- #"
+                        ++ (show . ptrToWord $ Ptr pIndRoot#)
+                        ++ ": IND _@"
+                        ++ (show . ptrToWord $ Ptr dRoot#)
+                    ) of
+      (# _, res #) -> res
+
+intoIncomplete :: forall r a. (Region r) => Token %1 -> a -> Incomplete r a ()
+intoIncomplete = toLinear2 _intoIncomplete
+
+{-# INLINE _intoIncomplete #-}
+_intoIncomplete :: forall r a. (Region r) => Token -> a -> Incomplete r a ()
+_intoIncomplete _ x = case getRegionInfo @r of
+  RegionInfo (Compact c# _ (MVar m#)) -> case runRW# $ \s0 ->
+    case putInRegionIfNot# c# m# x s0 of
+      (# s1, xInRegion #) -> case anyToAddr# xInRegion s1 of
+        (# s2, pXInRegion# #) -> putDebugLn# message (# s2, Incomplete (xInRegion, ()) #)
+          where
+            message =
+              ( "intoIncomplete: [region] <- #"
+                  ++ (show . ptrToWord $ Ptr pXInRegion#)
+                  ++ ": [value]"
+              ) of
+    (# _, res #) -> res
+
+fromIncomplete_ :: forall r a. (Region r) => Incomplete r a () %1 -> Ur a
+fromIncomplete_ = toLinear _fromIncomplete_
+
+{-# NOINLINE _fromIncomplete_ #-}
+_fromIncomplete_ :: forall r a. (Region r) => Incomplete r a () -> Ur a
+_fromIncomplete_ (Incomplete (root, ())) = case getRegionInfo @r of
+  (RegionInfo (Compact c# _ (MVar m#))) -> case runRW# $ \s0 -> case takeMVar# m# s0 of
+    (# s1, () #) -> case compactAddShallow# @(Ur a) c# ((unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# 'Ur))) s1 of
+      (# s2, receiver #) -> case anyToAddr# receiver s2 of
+        (# s3, pReceiver# #) -> case getSlots1# receiver s3 of
+          (# s4, (# dRoot# #) #) -> case putMVar# m# () s4 of
+            s5 -> case affect# dRoot# root s5 of
+              (# s6, pRoot# #) -> putDebugLn# message (# s6, receiver #)
+                where
+                  message =
+                    ( "fromIncomplete_: [region] <- #"
+                        ++ (show . ptrToWord $ Ptr pReceiver#)
+                        ++ ": Ur _@"
+                        ++ (show . ptrToWord $ Ptr dRoot#)
+                        ++ "\nfromIncomplete: @"
+                        ++ (show . ptrToWord $ Ptr dRoot#)
+                        ++ " <- #"
+                        ++ (show . ptrToWord $ Ptr pRoot#)
+                        ++ ": [root]"
+                    ) of
+    (# _, res #) -> res
+
+
+fromIncomplete :: forall r a b. (Region r) => Incomplete r a (Ur b) %1 -> Ur (a, b)
+fromIncomplete = toLinear _fromIncomplete
+
+{-# NOINLINE _fromIncomplete #-}
+_fromIncomplete :: forall r a b. (Region r) => Incomplete r a (Ur b) -> Ur (a, b)
+_fromIncomplete (Incomplete (root, uCompanion)) = case getRegionInfo @r of
+  (RegionInfo (Compact c# _ (MVar m#))) -> case runRW# $ \s0 -> case takeMVar# m# s0 of
+    (# s1, () #) -> case compactAddShallow# @(Ur (a, b)) c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# 'Ur)) s1 of
+      (# s2, receiver #) -> case anyToAddr# receiver s2 of
+        (# s3, pReceiver# #) -> case getSlots1# receiver s3 of
+          (# s4, (# d# #) #) -> case compactAddShallow# @(a, b) c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# '(,))) s4 of
+            (# s5, pair #) -> case affect# d# pair s5 of
+              (# s6, pPair# #) -> case getSlots2# pair s6 of
+                (# s7, (# dRoot#, dCompanion# #) #) -> case putMVar# m# () s7 of
+                  s8 -> case affect# dRoot# root s8 of
+                    (# s9, pRoot# #) -> case uCompanion of
+                      Ur companion -> case putInRegionIfNot# c# m# companion s9 of
+                        (# s10, companionInRegion #) -> case affect# dCompanion# companionInRegion s10 of
+                          (# s11, pCompanionInRegion# #) -> putDebugLn# message (# s11, receiver #)
+                            where
+                              message =
+                                ( "fromIncomplete: [region] <- #"
+                                    ++ (show . ptrToWord $ Ptr pReceiver#)
+                                    ++ ": Ur _@"
+                                    ++ (show . ptrToWord $ Ptr d#)
+                                    ++ "\nfromIncomplete: @"
+                                    ++ (show . ptrToWord $ Ptr d#)
+                                    ++ " <- #"
+                                    ++ (show . ptrToWord $ Ptr pPair#)
+                                    ++ ": (,) _@"
+                                    ++ (show . ptrToWord $ Ptr dRoot#)
+                                    ++ " _@"
+                                    ++ (show . ptrToWord $ Ptr dCompanion#)
+                                    ++ "\nfromIncomplete: @"
+                                    ++ (show . ptrToWord $ Ptr dRoot#)
+                                    ++ " <- #"
+                                    ++ (show . ptrToWord $ Ptr pRoot#)
+                                    ++ ": [root]"
+                                    ++ "\nfromIncomplete: @"
+                                    ++ (show . ptrToWord $ Ptr dCompanion#)
+                                    ++ " <- #"
+                                    ++ (show . ptrToWord $ Ptr pCompanionInRegion#)
+                                    ++ ": [companion]"
+                                ) of
+    (# _, res #) -> res
+
+-------------------------------------------------------------------------------
+-- Metaprogramming stuff for dests
+-------------------------------------------------------------------------------
+
+data Dest r a = Dest Addr#
+
+fill :: forall lCtor (r :: Type) (a :: Type). (Fill lCtor a, Region r) => Dest r a %1 -> DestsOf lCtor r a
+fill = toLinear (_fill @lCtor @a @r)
+{-# INLINE fill #-}
+
+fillComp :: forall r a b. (Region r) => Incomplete r a b %1 -> Dest r a %1 -> b
+fillComp = toLinear2 _fillComp
+{-# INLINE fillComp #-}
+
+fillLeaf :: forall r a. (Region r) => a -> Dest r a %1 -> ()
+fillLeaf x = fillComp (intoIncomplete @r Token x)
+{-# INLINE fillLeaf #-}
+
+_fillComp :: forall r a b. (Region r) => Incomplete r a b -> Dest r a -> b
+_fillComp (Incomplete (root, companion)) (Dest d#) = case runRW# $ \s0 -> case affect# d# root s0 of
+  (# s1, pRoot# #) -> putDebugLn# message (# s1, companion #)
+    where
+      message =
+        ( "fillComp: @"
+            ++ (show . ptrToWord $ Ptr d#)
+            ++ " <- #"
+            ++ (show . ptrToWord $ Ptr pRoot#)
+            ++ ": [Incomplete OR value]"
+        ) of
+  (# _, res #) -> res
+
+class Fill lCtor (a :: Type) where
+  _fill :: forall (r :: Type). Region r => Dest r a -> DestsOf lCtor r a
+
+instance (specCtor ~ LiftedCtorToSpecCtor lCtor a, GFill# lCtor specCtor a) => Fill lCtor a where
+  _fill :: forall (r :: Type). Region r =>  Dest r a -> DestsOf lCtor r a
+  _fill (Dest d#) = case getRegionInfo @r of
+    (RegionInfo (Compact c# _ (MVar m#))) -> case runRW# (gFill# @lCtor @specCtor @a @r c# m# d#) of (# _, res #) -> res
+  {-# INLINE _fill #-}
+
+-- ctor :: (Meta, [(Meta, Type)])
+class GFill# lCtor (specCtor :: (Meta, [(Meta, Type)])) (a :: Type) where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf specCtor r #)
+
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case putMVar# m# () s3 of
+              s4 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) []) (# s4, () #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots1# xInRegion s3 of
+              (# s4, (# d0# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#]) (# s5, (Dest d0# :: Dest r t0) #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots2# xInRegion s3 of
+              (# s4, (# d0#, d1# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#, Ptr d1#]) (# s5, (Dest d0# :: Dest r t0, Dest d1# :: Dest r t1) #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots3# xInRegion s3 of
+              (# s4, (# d0#, d1#, d2# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#, Ptr d1#, Ptr d2#]) (# s5, (Dest d0# :: Dest r t0, Dest d1# :: Dest r t1, Dest d2# :: Dest r t2) #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots4# xInRegion s3 of
+              (# s4, (# d0#, d1#, d2#, d3# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#, Ptr d1#, Ptr d2#, Ptr d3#]) (# s5, (Dest d0# :: Dest r t0, Dest d1# :: Dest r t1, Dest d2# :: Dest r t2, Dest d3# :: Dest r t3) #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots5# xInRegion s3 of
+              (# s4, (# d0#, d1#, d2#, d3#, d4# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#, Ptr d1#, Ptr d2#, Ptr d3#, Ptr d4#]) (# s5, (Dest d0# :: Dest r t0, Dest d1# :: Dest r t1, Dest d2# :: Dest r t2, Dest d3# :: Dest r t3, Dest d4# :: Dest r t4) #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4), '( 'MetaSel f5 u5 ss5 ds5, t5)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4), '( 'MetaSel f5 u5 ss5 ds5, t5)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4), '( 'MetaSel f5 u5 ss5 ds5, t5)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots6# xInRegion s3 of
+              (# s4, (# d0#, d1#, d2#, d3#, d4#, d5# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#, Ptr d1#, Ptr d2#, Ptr d3#, Ptr d4#, Ptr d5#]) (# s5, (Dest d0# :: Dest r t0, Dest d1# :: Dest r t1, Dest d2# :: Dest r t2, Dest d3# :: Dest r t3, Dest d4# :: Dest r t4, Dest d5# :: Dest r t5) #)
+  {-# INLINE gFill# #-}
+
+-- TODO: add constraints on ds_i variables to ensure no unpacking
+instance (Generic a, repA ~ Rep a (), metaA ~ GDatatypeMetaOf repA, Datatype metaA, 'MetaCons symCtor fix hasSel ~ metaCtor, Constructor metaCtor, LiftedCtorToSymbol lCtor ~ symCtor, 'Just '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4), '( 'MetaSel f5 u5 ss5 ds5, t5), '( 'MetaSel f6 u6 ss6 ds6, t6)]) ~ GSpecCtorOf symCtor (Rep a ())) => GFill# lCtor '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4), '( 'MetaSel f5 u5 ss5 ds5, t5), '( 'MetaSel f6 u6 ss6 ds6, t6)]) a where
+  gFill# :: forall (r :: Type). Compact# -> MVar# RealWorld () -> Addr# -> State# RealWorld -> (# State# RealWorld, GDestsOf '(metaCtor, '[ '( 'MetaSel f0 u0 ss0 ds0, t0), '( 'MetaSel f1 u1 ss1 ds1, t1), '( 'MetaSel f2 u2 ss2 ds2, t2), '( 'MetaSel f3 u3 ss3 ds3, t3), '( 'MetaSel f4 u4 ss4 ds4, t4), '( 'MetaSel f5 u5 ss5 ds5, t5), '( 'MetaSel f6 u6 ss6 ds6, t6)]) r #)
+  gFill# c# m# d# s0 =
+    case takeMVar# m# s0 of
+      (# s1, () #) ->
+        case compactAddShallow# c# (unsafeCoerceAddr (reifyStgInfoPtr# (# #) :: InfoPtrPlaceholder# lCtor)) s1 of
+          (# s2, xInRegion #) -> case affect# d# xInRegion s2 of
+            (# s3, pXInRegion# #) -> case getSlots7# xInRegion s3 of
+              (# s4, (# d0#, d1#, d2#, d3#, d4#, d5#, d6# #) #) -> case putMVar# m# () s4 of
+                s5 -> putDebugLn# (showFill (Ptr d#) (Ptr pXInRegion#) (conName @metaCtor undefined) [Ptr d0#, Ptr d1#, Ptr d2#, Ptr d3#, Ptr d4#, Ptr d5#, Ptr d6#]) (# s5, (Dest d0# :: Dest r t0, Dest d1# :: Dest r t1, Dest d2# :: Dest r t2, Dest d3# :: Dest r t3, Dest d4# :: Dest r t4, Dest d5# :: Dest r t5, Dest d6# :: Dest r t6) #)
+  {-# INLINE gFill# #-}
+
+type family GDestsOf (specCtor :: (Meta, [(Meta, Type)])) (r :: Type) :: Type where
+  GDestsOf '(_, '[]) _ = ()
+  GDestsOf '(_, '[ '(_, t)]) r = Dest r t
+  GDestsOf '(_, '[ '(_, t0), '(_, t1)]) r = (Dest r t0, Dest r t1)
+  GDestsOf '(_, '[ '(_, t0), '(_, t1), '(_, t2)]) r = (Dest r t0, Dest r t1, Dest r t2)
+  GDestsOf '(_, '[ '(_, t0), '(_, t1), '(_, t2), '(_, t3)]) r = (Dest r t0, Dest r t1, Dest r t2, Dest r t3)
+  GDestsOf '(_, '[ '(_, t0), '(_, t1), '(_, t2), '(_, t3), '(_, t4)]) r = (Dest r t0, Dest r t1, Dest r t2, Dest r t3, Dest r t4)
+  GDestsOf '(_, '[ '(_, t0), '(_, t1), '(_, t2), '(_, t3), '(_, t4), '(_, t5)]) r = (Dest r t0, Dest r t1, Dest r t2, Dest r t3, Dest r t4, Dest r t5)
+  GDestsOf '(_, '[ '(_, t0), '(_, t1), '(_, t2), '(_, t3), '(_, t4), '(_, t5), '(_, t6)]) r = (Dest r t0, Dest r t1, Dest r t2, Dest r t3, Dest r t4, Dest r t5, Dest r t6)
+  GDestsOf _ _ = TypeError ('Text "GDestsOf not implemented for constructors with more than 7 fields")
+
+type family DestsOf lCtor (r :: Type) (a :: Type) where
+  DestsOf lCtor r a = GDestsOf (LiftedCtorToSpecCtor lCtor a) r
+
+type family GDatatypeMetaOf (repA :: Type) :: Meta where
+  GDatatypeMetaOf (D1 meta f p) = meta
+  GDatatypeMetaOf (M1 _ _ f p) = GDatatypeMetaOf (f p)
+  GDatatypeMetaOf _ = TypeError ('Text "No match for GDatatypeMetaOf")
+
+type family GFieldsOf (repA :: Type) :: [(Meta, Type)] where
+  GFieldsOf (S1 meta f p) = '[ '(meta, GSlotTypeOf (f p))]
+  GFieldsOf (U1 _) = '[]
+  GFieldsOf ((f :*: g) p) = GFieldsOf (f p) ++ GFieldsOf (g p)
+  GFieldsOf (M1 _ _ f p) = GFieldsOf (f p)
+  GFieldsOf _ = TypeError ('Text "No match for GFieldsOf")
+
+type family GSlotTypeOf (repA :: Type) :: Type where
+  GSlotTypeOf (K1 _ c _) = c
+  GSlotTypeOf (M1 _ _ f p) = GSlotTypeOf (f p)
+  GSlotTypeOf _ = TypeError ('Text "No match for GSlotTypeOf")
+
+type family GSpecCtorOf (symCtor :: Symbol) (repA :: Type) :: Maybe (Meta, [(Meta, Type)]) where
+  GSpecCtorOf symCtor (C1 ('MetaCons symCtor x y) f p) = 'Just '(('MetaCons symCtor x y), GFieldsOf (f p))
+  GSpecCtorOf symCtor (C1 ('MetaCons _ _ _) _ _) = 'Nothing
+  GSpecCtorOf symCtor ((f :+: g) p) = GSpecCtorOf symCtor (f p) <|> GSpecCtorOf symCtor (g p)
+  GSpecCtorOf symCtor (V1 _) = 'Nothing
+  GSpecCtorOf symCtor (M1 _ _ f p) = GSpecCtorOf symCtor (f p)
+  GSpecCtorOf _ _ = TypeError ('Text "No match for GHasCtor")
+
+type family LiftedCtorToSpecCtor lCtor (a :: Type) :: (Meta, [(Meta, Type)]) where
+  LiftedCtorToSpecCtor lCtor a = FromJust (GSpecCtorOf (LiftedCtorToSymbol lCtor) (Rep a ()))
+
+type family (a :: [k]) ++ (b :: [k]) :: [k] where
+  '[] ++ y = y
+  (x : xs) ++ y = x : (xs ++ y)
+  _ ++ _ = TypeError ('Text "No match for ++")
+
+type family FromJust (x :: Maybe k) :: k where
+  FromJust ('Just v) = v
+  FromJust 'Nothing = TypeError ('Text "FromJust error: got 'Nothing")
+
+type family (x :: Maybe k) <|> (y :: Maybe k) :: Maybe k where
+  ('Just v) <|> _ = 'Just v
+  'Nothing <|> y = y
\ No newline at end of file
diff --git a/src-version-changes/ghc-dps-compact/before/Compact/Destination.hs b/src-version-changes/ghc-dps-compact/before/Compact/Destination.hs
new file mode 100644
index 00000000..6e545773
--- /dev/null
+++ b/src-version-changes/ghc-dps-compact/before/Compact/Destination.hs
@@ -0,0 +1,2 @@
+module Compact.Destination () where
+
diff --git a/src-version-changes/ghc-dps-compact/before/Compact/Destination/Internal.hs b/src-version-changes/ghc-dps-compact/before/Compact/Destination/Internal.hs
new file mode 100644
index 00000000..2b426658
--- /dev/null
+++ b/src-version-changes/ghc-dps-compact/before/Compact/Destination/Internal.hs
@@ -0,0 +1 @@
+module Compact.Destination.Internal () where
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact.hs
new file mode 100644
index 00000000..6e5dc627
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact.hs
@@ -0,0 +1,20 @@
+module Test.Compact where
+
+import Test.Compact.BFTraversal (bfTraversalTests)
+import Test.Compact.DList (dlistTests)
+import Test.Compact.Map (mapTests)
+import Test.Compact.Queue (queueTests)
+import Test.Compact.SExpr (sexprTests)
+
+import Test.Tasty
+
+compactTests :: TestTree
+compactTests =
+    testGroup
+        "DPS interface for compact regions"
+        [ bfTraversalTests
+        , dlistTests
+        , mapTests
+        , queueTests
+        , sexprTests
+        ]
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/BFTraversal.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/BFTraversal.hs
new file mode 100644
index 00000000..06f9940b
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/BFTraversal.hs
@@ -0,0 +1,23 @@
+module Test.Compact.BFTraversal where
+
+import Compact.BFTraversal
+import Test.Compact.Utils
+
+dataset :: BinTree ()
+dataset = Node
+                        ()
+                        (Node () (Leaf ()) (Leaf ()))
+                        (Node () (Leaf ()) Nil)
+
+expected :: (BinTree Int, Int)
+                    expected =
+                      ( Node
+                          0
+                          (Node 1 (Leaf 3) (Leaf 4))
+                          (Node 2 (Leaf 5) Nil),
+                        6
+                      )
+
+bftraversalTests :: TestTree
+bftraversalTests =
+  safetySameAsExpected "Breadth-first tree traversal" impls dataset expected
\ No newline at end of file
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/DList.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/DList.hs
new file mode 100644
index 00000000..f4f3d8b0
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/DList.hs
@@ -0,0 +1,10 @@
+module Test.Compact.DList where
+
+import Compact.DList
+import Test.Compact.Utils
+
+dataset :: [[Int]]
+dataset = fmap (\i -> [(10 * i + 0)..(10 * i + 9)]) [0..(((2^10) `div` 10) - 1)]
+
+dlistTests :: TestTree
+dlistTests = safetySameAsFirstImpl "List & Difference lists concatenation" impls dataset
\ No newline at end of file
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Map.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Map.hs
new file mode 100644
index 00000000..485166db
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Map.hs
@@ -0,0 +1,11 @@
+{-# LANGUAGE LinearTypes #-}
+module Test.Compact.Map where
+
+import Compact.Map
+import Test.Compact.Utils
+
+dataset :: (Int %1 -> Int, [Int])
+dataset = (\x -> 2 * x + 1, [1 .. 2^10])
+
+mapTests :: TestTree
+mapTests = safetySameAsFirstImpl "Map function over list of integers" impls dataset
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Queue.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Queue.hs
new file mode 100644
index 00000000..22e9e723
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Queue.hs
@@ -0,0 +1,7 @@
+module Test.Compact.Queue where
+
+import Compact.Queue
+import Test.Compact.Utils
+
+queueTests :: TestTree
+queueTests = safetySameAsFirstImpl "Enqueue elements in a queue" impls (2^10)
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/SExpr.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/SExpr.hs
new file mode 100644
index 00000000..afb82720
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/SExpr.hs
@@ -0,0 +1,40 @@
+module Test.Compact.SExpr where
+
+import Data.ByteString.Char8 (ByteString, unpack)
+import Compact.SExpr
+import Test.Compact.Utils
+
+dataset :: ByteString
+dataset = unpack "(ert-deftest company-shows-keywords-alongside-completions-alphabetically () :tags '(company) (switch-to-buffer \"*TESTING COMPANY MODE ~ Python*\"))"
+
+expected :: Either SExprParseError SExpr
+expected =
+  Right
+    ( SList
+        105
+        [ SSymbol 1 "ert-deftest",
+          SSymbol 17 "company-shows-keywords-alongside-completions-alphabetically",
+          SList
+            74
+            [ SSymbol 1 "tags",
+              SList
+                7
+                [ SSymbol 2 "quote",
+                  SList
+                    3
+                    [ SSymbol 3 "company"
+                    ]
+                ],
+              SList
+                74
+                [ SList
+                    1
+                    [ SSymbol 1 "switch-to-buffer" ],
+                  SString 54 "*TESTING COMPANY MODE ~ Python*"
+                ]
+            ]
+        ]
+    )
+
+sexprTests :: TestTree
+sexprTests = safetySameAsExpected "S-expression parser" impls dataset expected
diff --git a/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Utils.hs b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Utils.hs
new file mode 100644
index 00000000..03247026
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/after/Test/Compact/Utils.hs
@@ -0,0 +1,31 @@
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE RankNTypes #-}
+
+module Test.Compact.Utils where
+
+import Data.Functor ((<&>))
+import Test.Tasty (TestTree, testGroup)
+import Test.Tasty.HUnit (testCaseInfo, assertEqual)
+
+safetySameAsFirstImpl :: forall m a r. (Show r, Eq r) => String -> [(a %m -> r, String, Bool)] -> a -> TestTree
+safetySameAsFirstImpl name impls sampleData = do
+  let ((refImpl, refImplName, _):otherImpls) = impls
+  testGroup 
+    ("All " ++ name ++ " implementations give the same result")
+    (otherImpls <&> \(impl, implName, _) ->
+      testCaseInfo (refImplName ++ " and " ++ implName ++ " give the same result") $ do
+        let expected = refImpl sampleData
+            actual = impl sampleData
+        assertEqual "same result" expected actual
+        return "")
+
+safetySameAsExpected :: forall m a r. (Show r, Eq r) => String -> [(a %m -> r, String, Bool)] -> a -> r -> TestTree
+safetySameAsFirstImpl name impls sampleData expected = do
+  let ((refImpl, refImplName, _):otherImpls) = impls
+  testGroup 
+    ("All " ++ name ++ " implementations give the same result")
+    (otherImpls <&> \(impl, implName, _) ->
+      testCaseInfo (refImplName ++ " gives the expected result") $ do
+        let actual = impl sampleData
+        assertEqual "same result" expected actual
+        return "")
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact.hs
new file mode 100644
index 00000000..4ffd7465
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact.hs
@@ -0,0 +1,9 @@
+module Test.Compact where
+
+import Test.Tasty
+
+compactTests :: TestTree
+compactTests =
+    testGroup
+        "DPS interface for compact regions (unsupported in this GHC version)"
+        []
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/BFTraversal.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/BFTraversal.hs
new file mode 100644
index 00000000..632ad697
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/BFTraversal.hs
@@ -0,0 +1 @@
+module Test.Compact.BFTraversal () where
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/DList.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/DList.hs
new file mode 100644
index 00000000..36d6bade
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/DList.hs
@@ -0,0 +1 @@
+module Test.Compact.DList () where
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Map.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Map.hs
new file mode 100644
index 00000000..062cd87e
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Map.hs
@@ -0,0 +1 @@
+module Test.Compact.Map () where
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Queue.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Queue.hs
new file mode 100644
index 00000000..ba038fa0
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Queue.hs
@@ -0,0 +1 @@
+module Test.Compact.Queue () where
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/SExpr.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/SExpr.hs
new file mode 100644
index 00000000..115260d7
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/SExpr.hs
@@ -0,0 +1 @@
+module Test.Compact.SExpr () where
diff --git a/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Utils.hs b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Utils.hs
new file mode 100644
index 00000000..8fdd5a96
--- /dev/null
+++ b/test-examples-version-changes/ghc-dps-compact/before/Test/Compact/Utils.hs
@@ -0,0 +1 @@
+module Test.Compact.Utils () where
diff --git a/test-version-changes/ghc-dps-compact/after/Test/Compact/Destination.hs b/test-version-changes/ghc-dps-compact/after/Test/Compact/Destination.hs
new file mode 100644
index 00000000..9a21691b
--- /dev/null
+++ b/test-version-changes/ghc-dps-compact/after/Test/Compact/Destination.hs
@@ -0,0 +1,105 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ImpredicativeTypes #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE LinearTypes #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module Test.Compact.Destination (destinationTests) where
+
+import Compact.Destination
+import Control.Functor.Linear ((<&>))
+import Control.Monad (return)
+import GHC.Generics (Generic)
+import Prelude.Linear hiding (Eq)
+import Test.Tasty
+import Test.Tasty.HUnit
+import Prelude (Eq)
+import Data.Proxy (Proxy)
+
+-- Launch with
+-- cabal test -w $(pwd)/ghc@580d39a221/bin/ghc --allow-newer linear-dest:test:test --test-options='+RTS -N1 -RTS' --test-show-details=streaming
+
+destinationTests :: TestTree
+destinationTests =
+  testGroup
+    "DPS interface for compact regions"
+    [ testCaseInfo "Dests for compact region: compose when RHS is freshly allocated" compOnFreshAlloc,
+      testCaseInfo "Dests for compact region: compose when RHS has already been filled" compOnUsedAlloc,
+      testCaseInfo "Dests for compact region: fill custom data (via generic) and return companion value with fromIncomplete" fillCustomDataAndExtract
+    ]
+
+data Foo a b = MkFoo {unBar :: a, unBaz :: (b, b), unBoo :: a} deriving (Eq, Generic, Show)
+
+compOnFreshAlloc :: IO String
+compOnFreshAlloc = do
+  let actual :: Ur (Int, Int)
+      !actual = withRegion $ \(_ :: Proxy r) t -> case dup2 t of
+        (t', t'') ->
+          fromIncomplete_
+            $ (alloc @r t')
+            <&> ( \dp ->
+                    case (dp & fill @'(,)) of
+                      (dl, dr) ->
+                        dl
+                          & fillLeaf 1
+                          `lseq` dr
+                          & fillComp (alloc @r t'')
+                          & fillLeaf 2
+                )
+      expected :: Ur (Int, Int)
+      !expected = Ur (1, 2)
+  assertEqual "same result" expected actual
+  return ""
+
+compOnUsedAlloc :: IO String
+compOnUsedAlloc = do
+  let actual :: Ur (Int, (Int, Int))
+      !actual = withRegion $ \(_ :: Proxy r) t -> case dup2 t of
+        (t', t'') ->
+          fromIncomplete_
+            $ (alloc @r t')
+            <&> ( \dp ->
+                    case dp & fill @'(,) of
+                      (dl, dr) ->
+                        dl
+                          & fillLeaf 1
+                          `lseq` dr
+                          & fillComp ((alloc @r t'') <&> (\dp' -> case dp' & fill @'(,) of (dr1, dr2) -> dr1 & fillLeaf 2 `lseq` dr2))
+                          & fillLeaf 3
+                )
+      expected :: Ur (Int, (Int, Int))
+      !expected = Ur (1, (2, 3))
+  assertEqual "same result" expected actual
+  return ""
+
+fillCustomDataAndExtract :: IO String
+fillCustomDataAndExtract = do
+  let actual :: Ur (Foo Int Char, Int)
+      !actual = withRegion $ \(_ :: Proxy r) t ->
+        fromIncomplete
+          $ (alloc @r t)
+          <&> ( \d ->
+                  case d & fill @'MkFoo of
+                    (dBar, dBaz, dBoo) ->
+                      dBar
+                        & fillLeaf 1
+                        `lseq` ( case dBaz & fill @'(,) of
+                                   (dl, dr) -> dl & fillLeaf 'a' `lseq` dr & fillLeaf 'b'
+                               )
+                        `lseq` dBoo
+                        & fillLeaf 2
+                        `lseq` Ur 14
+              )
+      expected :: Ur (Foo Int Char, Int)
+      !expected = Ur (MkFoo 1 ('a', 'b') 2, 14)
+  assertEqual "same result" expected actual
+  return ""
diff --git a/test-version-changes/ghc-dps-compact/before/Test/Compact/Destination.hs b/test-version-changes/ghc-dps-compact/before/Test/Compact/Destination.hs
new file mode 100644
index 00000000..38ecd7ea
--- /dev/null
+++ b/test-version-changes/ghc-dps-compact/before/Test/Compact/Destination.hs
@@ -0,0 +1,9 @@
+module Test.Compact.Destination (destinationTests) where
+
+import Test.Tasty
+
+destinationTests :: TestTree
+destinationTests =
+    testGroup
+        "DPS interface for compact regions (unsupported in this GHC version)"
+        []
\ No newline at end of file
diff --git a/test/Main.hs b/test/Main.hs
index e9ff6db6..f1f441cf 100644
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -12,6 +12,7 @@ import Test.Data.Replicator (replicatorInspectionTests)
 import Test.Data.Set.Mutable (mutSetTests)
 import Test.Data.V (vInspectionTests)
 import Test.Data.Vector.Mutable (mutVecTests)
+import Test.Compact.Destination (destinationTests)
 import Test.Tasty
 
 main :: IO ()
@@ -29,7 +30,8 @@ allTests =
           mutSetTests,
           destArrayTests,
           polarizedArrayTests,
-          genericTests
+          genericTests,
+          destinationTests
         ],
       testGroup
         "Inspection tests"