diff --git a/CHANGELOG.md b/CHANGELOG.md
index 20bf52f..ef9791d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+0.3.13 (2019-06-25)
+------------------
+* Updated for terraform v0.12 syntax
+
 0.2.1 (2016-04-14)
 ------------------
 * Fixes for mutliple configuration blocks with same name
diff --git a/README.rst b/README.rst
index de17f6b..f9a49a0 100644
--- a/README.rst
+++ b/README.rst
@@ -12,6 +12,11 @@ The grammar and many of the tests/fixtures were copied/ported from the
 golang parser into pyhcl. All releases are tested with a variety of 
 python versions from Python 2.7 onward.
 
+This version has been modified to work with terraform 0.12 syntax.  
+It should be backward compatible with earlier versions.  
+It doesn't cover every situation.  See discussion in pull request:
+https://github.com/virtuald/pyhcl/pull/57
+
 Installation
 ============
 
diff --git a/src/hcl/lexer.py b/src/hcl/lexer.py
index 176d7dc..de02865 100644
--- a/src/hcl/lexer.py
+++ b/src/hcl/lexer.py
@@ -36,7 +36,10 @@ class Lexer(object):
         'IDENTIFIER',
         'EQUAL',
         'STRING',
+        'ADD',
         'MINUS',
+        'MULTIPLY',
+        'DIVIDE',
         'LEFTBRACE',
         'RIGHTBRACE',
         'LEFTBRACKET',
@@ -44,6 +47,17 @@ class Lexer(object):
         'PERIOD',
         'EPLUS',
         'EMINUS',
+        'LEFTPAREN',
+        'RIGHTPAREN',
+        'QMARK',
+        'COLON',
+        'ASTERISK_PERIOD',
+        'GT',
+        'LT',
+        'EQ',
+        'NE',
+        'LE',
+        'GE',
     )
 
     states = (
@@ -63,7 +77,7 @@ def t_EMINUS(self, t):
         return t
 
     def t_EPLUS(self, t):
-        r'(?<=\d|\.)[eE]\+?'
+        r'(?<=\d)[eE]\+?|(?<=\d\.)[eE]\+?'
         return t
 
     def t_FLOAT(self, t):
@@ -91,6 +105,42 @@ def t_COMMA(self, t):
         r','
         return t
 
+    def t_QMARK(self, t):
+        r'\?'
+        return t
+
+    def t_COLON(self, t):
+        r':'
+        return t
+
+    def t_ASTERISK_PERIOD(self, t):
+        r'\*\.'
+        return t
+
+    def t_GT(self, t):
+        r'(?<!>)>(?!>|=)'
+        return t
+
+    def t_LT(self, t):
+        r'(?<!<)<(?!<|=)'
+        return t
+
+    def t_EQ(self, t):
+        r'=='
+        return t
+
+    def t_NE(self, t):
+        r'!='
+        return t
+
+    def t_LE(self, t):
+        r'<='
+        return t
+
+    def t_GE(self, t):
+        r'>='
+        return t
+
     def t_IDENTIFIER(self, t):
         r'[^\W\d][\w.-]*'
         t.value = text_type(t.value)
@@ -259,13 +309,12 @@ def t_heredoc_eof(self, t):
     t_tabbedheredoc_ignoring = t_heredoc_ignoring
     t_tabbedheredoc_eof = t_heredoc_eof
 
-    t_EQUAL = r'='
-    t_MINUS = r'-'
-
     t_LEFTBRACE = r'\{'
     t_RIGHTBRACE = r'\}'
     t_LEFTBRACKET = r'\['
     t_RIGHTBRACKET = r'\]'
+    t_LEFTPAREN = r'\('
+    t_RIGHTPAREN = r'\)'
 
     def t_COMMENT(self, t):
         r'(\#|(//)).*'
@@ -283,6 +332,12 @@ def t_newline(self, t):
 
     t_ignore = ' \t\r\f\v'
 
+    t_EQUAL = r'(?<!=)=(?!=)'
+    t_ADD = r'\+'
+    t_MINUS = r'-'
+    t_MULTIPLY = r'\*'
+    t_DIVIDE = r'/'
+
     # Error handling rule
     def t_error(self, t):
         if t.value.startswith('/*'):
diff --git a/src/hcl/parser.py b/src/hcl/parser.py
index 444497d..02b1891 100644
--- a/src/hcl/parser.py
+++ b/src/hcl/parser.py
@@ -49,7 +49,10 @@ class HclParser(object):
         'IDENTIFIER',
         'EQUAL',
         'STRING',
+        'ADD',
         'MINUS',
+        'MULTIPLY',
+        'DIVIDE',
         'LEFTBRACE',
         'RIGHTBRACE',
         'LEFTBRACKET',
@@ -57,6 +60,17 @@ class HclParser(object):
         'PERIOD',
         'EPLUS',
         'EMINUS',
+        'LEFTPAREN',
+        'RIGHTPAREN',
+        'QMARK',
+        'COLON',
+        'ASTERISK_PERIOD',
+        'GT',
+        'LT',
+        'EQ',
+        'NE',
+        'LE',
+        'GE',
     )
 
     #
@@ -152,13 +166,57 @@ def p_objectkey_0(self, p):
             self.print_p(p)
         p[0] = p[1]
 
+    def p_objectkey_1(self, p):
+        '''
+        objectkey : IDENTIFIER ADD number
+                  | number ADD IDENTIFIER
+                  | IDENTIFIER MINUS number
+                  | number MINUS IDENTIFIER
+                  | IDENTIFIER MULTIPLY number
+                  | number MULTIPLY IDENTIFIER
+                  | IDENTIFIER DIVIDE number
+                  | number DIVIDE IDENTIFIER
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = (str(p[1]), str(p[2]), str(p[3]))
+
+    def p_objectbrackets_0(self, p):
+        "objectbrackets : IDENTIFIER LEFTBRACKET objectkey RIGHTBRACKET"
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] + p[2] + p[3] + p[4]
+
+    def p_objectbrackets_1(self, p):
+        '''
+        objectbrackets : IDENTIFIER LEFTBRACKET objectkey RIGHTBRACKET PERIOD IDENTIFIER
+                       | IDENTIFIER LEFTBRACKET NUMBER RIGHTBRACKET PERIOD IDENTIFIER
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] + p[2] + str(p[3]) + p[4] + p[5] + p[6]
+
     def p_objectitem_0(self, p):
         '''
         objectitem : objectkey EQUAL number
                    | objectkey EQUAL BOOL
                    | objectkey EQUAL STRING
+                   | objectkey EQUAL IDENTIFIER
                    | objectkey EQUAL object
+                   | objectkey EQUAL objectkey
                    | objectkey EQUAL list
+                   | objectkey EQUAL objectbrackets
+                   | objectkey EQUAL function
+                   | objectkey EQUAL booleanexp
+                   | objectkey COLON number
+                   | objectkey COLON BOOL
+                   | objectkey COLON STRING
+                   | objectkey COLON IDENTIFIER
+                   | objectkey COLON object
+                   | objectkey COLON objectkey
+                   | objectkey COLON list
+                   | objectkey COLON objectbrackets
+                   | objectkey COLON booleanexp
         '''
         if DEBUG:
             self.print_p(p)
@@ -170,26 +228,73 @@ def p_objectitem_1(self, p):
             self.print_p(p)
         p[0] = p[1]
 
-    def p_block_0(self, p):
-        "block : blockId object"
+    def p_objectitem_2(self, p):
+        '''
+        objectitem : objectkey EQUAL objectkey QMARK objectkey COLON objectkey
+                   | objectkey EQUAL objectkey QMARK objectkey COLON number
+                   | objectkey EQUAL objectkey QMARK objectkey COLON BOOL
+                   | objectkey EQUAL objectkey QMARK objectkey COLON function
+                   | objectkey EQUAL objectkey QMARK number COLON objectkey
+                   | objectkey EQUAL objectkey QMARK BOOL COLON objectkey
+                   | objectkey EQUAL objectkey QMARK function COLON objectkey
+                   | objectkey EQUAL objectkey QMARK number COLON number
+                   | objectkey EQUAL objectkey QMARK number COLON BOOL
+                   | objectkey EQUAL objectkey QMARK number COLON function
+                   | objectkey EQUAL objectkey QMARK BOOL COLON number
+                   | objectkey EQUAL objectkey QMARK BOOL COLON function
+                   | objectkey EQUAL objectkey QMARK BOOL COLON BOOL
+                   | objectkey EQUAL booleanexp QMARK objectkey COLON objectkey
+                   | objectkey EQUAL booleanexp QMARK objectkey COLON number
+                   | objectkey EQUAL booleanexp QMARK objectkey COLON BOOL
+                   | objectkey EQUAL booleanexp QMARK objectkey COLON function
+                   | objectkey EQUAL booleanexp QMARK number COLON objectkey
+                   | objectkey EQUAL booleanexp QMARK BOOL COLON objectkey
+                   | objectkey EQUAL booleanexp QMARK function COLON objectkey
+                   | objectkey EQUAL booleanexp QMARK number COLON number
+                   | objectkey EQUAL booleanexp QMARK number COLON BOOL
+                   | objectkey EQUAL booleanexp QMARK number COLON function
+                   | objectkey EQUAL booleanexp QMARK BOOL COLON number
+                   | objectkey EQUAL booleanexp QMARK BOOL COLON function
+                   | objectkey EQUAL booleanexp QMARK BOOL COLON BOOL
+        '''
         if DEBUG:
             self.print_p(p)
-        p[0] = (p[1], p[2])
+        p[0] = (p[1], p[3] + p[4] + str(p[5]) + p[6] + str(p[7]))
 
-    def p_block_1(self, p):
-        "block : blockId block"
+    def p_operator_0(self, p):
+        '''
+        operator : EQ
+                 | NE
+                 | LT
+                 | GT
+                 | LE
+                 | GE
+        '''
         if DEBUG:
             self.print_p(p)
-        p[0] = (p[1], {p[2][0]: p[2][1]})
+        p[0] = p[1]
 
-    def p_blockId(self, p):
+    def p_booleanexp_0(self, p):
         '''
-        blockId : IDENTIFIER
-                | STRING
+        booleanexp : objectkey operator objectkey
+                   | objectkey operator number
+                   | number operator objectkey
         '''
         if DEBUG:
             self.print_p(p)
-        p[0] = p[1]
+        p[0] = str(p[1]) + p[2] + str(p[3])
+
+    def p_block_0(self, p):
+        "block : objectkey object"
+        if DEBUG:
+            self.print_p(p)
+        p[0] = (p[1], p[2])
+
+    def p_block_1(self, p):
+        "block : objectkey block"
+        if DEBUG:
+            self.print_p(p)
+        p[0] = (p[1], {p[2][0]: p[2][1]})
 
     def p_list_0(self, p):
         '''
@@ -201,33 +306,163 @@ def p_list_0(self, p):
         p[0] = p[2]
 
     def p_list_1(self, p):
-        "list : LEFTBRACKET RIGHTBRACKET"
+        '''
+        list : LEFTBRACKET RIGHTBRACKET
+             | LEFTPAREN RIGHTPAREN
+        '''
         if DEBUG:
             self.print_p(p)
         p[0] = []
 
+    def p_list_2(self, p):
+        '''
+        list : LEFTPAREN LEFTBRACKET listitems RIGHTBRACKET PERIOD PERIOD PERIOD RIGHTPAREN
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = [p[3]] + [p[5] + p[6] + p[7]]
+
+    def p_list_of_lists_0(self, p):
+        '''
+        list_of_lists : list COMMA list
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1], p[3]
+
+    def p_list_of_lists_1(self, p):
+        '''
+        list_of_lists : list_of_lists COMMA list
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] + (p[3],)
+
+    def p_function_0(self, p):
+        '''
+        function : IDENTIFIER LEFTPAREN listitems RIGHTPAREN
+                 | IDENTIFIER LEFTPAREN list_of_lists RIGHTPAREN
+        '''
+        if DEBUG:
+            self.print_p(p)
+
+        p[0] = p[1] + p[2] + self.flatten(p[3]) + p[4]
+
+    def p_function_1(self, p):
+        '''
+        function : IDENTIFIER LEFTPAREN listitems COMMA RIGHTPAREN
+                 | IDENTIFIER LEFTPAREN list_of_lists COMMA RIGHTPAREN
+        '''
+        if DEBUG:
+            self.print_p(p)
+
+        p[0] = p[1] + p[2] + self.flatten(p[3]) + p[5]
+
+    def p_function_2(self, p):
+        '''
+        function : IDENTIFIER LEFTPAREN list PERIOD PERIOD PERIOD RIGHTPAREN
+        '''
+        if DEBUG:
+            self.print_p(p)
+
+        p[0] = p[1] + p[2] + self.flatten(p[3]) + p[4] + p[5] + p[6] + p[7]
+
+    def p_function_3(self, p):
+        '''
+        function : IDENTIFIER LEFTPAREN LEFTBRACKET list_of_lists RIGHTBRACKET PERIOD PERIOD PERIOD RIGHTPAREN
+        '''
+        if DEBUG:
+            self.print_p(p)
+
+        p[0] = (
+            p[1] + p[2] + p[3] + self.flatten(p[4]) + p[5] + p[6] + p[7] + p[8] + p[9]
+        )
+
+    def flatten(self, value):
+        returnValue = ""
+        if type(value) is dict:
+            returnValue = (
+                "{"
+                + ",".join(key + ":" + self.flatten(value[key]) for key in value)
+                + "}"
+            )
+        elif type(value) is list:
+            returnValue = ",".join(self.flatten(v) for v in value)
+        elif type(value) is tuple:
+            returnValue = " ".join(self.flatten(v) for v in value)
+        else:
+            returnValue = value
+        return returnValue
+
     def p_listitems_0(self, p):
-        "listitems : listitem"
+        '''
+        listitems : listitem
+                  | function
+                  | object COMMA
+                  | objectkey COMMA
+        '''
         if DEBUG:
             self.print_p(p)
         p[0] = [p[1]]
 
     def p_listitems_1(self, p):
-        "listitems : listitems COMMA listitem"
+        '''
+        listitems : listitems COMMA listitem
+                  | listitems COMMA function
+                  | listitems COMMA objectkey
+        '''
         if DEBUG:
             self.print_p(p)
         p[0] = p[1] + [p[3]]
 
-    def p_listitem(self, p):
+    def p_listitems_2(self, p):
+        '''
+        listitems : object COMMA object
+                  | object COMMA objectkey
+                  | objectkey COMMA objectkey
+                  | objectkey COMMA object
+                  | objectkey COMMA list
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = [p[1], p[3]]
+
+    def p_listitems_3(self, p):
+        '''
+        listitems : objectkey COMMA IDENTIFIER ASTERISK_PERIOD IDENTIFIER
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = [p[1], p[3] + p[4] + p[5]]
+
+    def p_listitems_4(self, p):
+        '''
+        listitems : objectkey list
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[2].insert(0, p[1])
+        p[0] = p[2]
+
+    def p_listitem_0(self, p):
         '''
         listitem : number
                  | object
-                 | STRING
+                 | objectkey
+                 | objectbrackets
         '''
         if DEBUG:
             self.print_p(p)
         p[0] = p[1]
 
+    def p_listitem_1(self, p):
+        '''
+        listitem : IDENTIFIER ASTERISK_PERIOD IDENTIFIER
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] + p[2] + p[3]
+
     def p_number_0(self, p):
         "number : int"
         if DEBUG:
@@ -252,6 +487,38 @@ def p_number_3(self, p):
             self.print_p(p)
         p[0] = float("{0}{1}".format(p[1], p[2]))
 
+    def p_number_4(self, p):
+        '''
+        number : number ADD number
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] + p[3]
+
+    def p_number_5(self, p):
+        '''
+        number : number MINUS number
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] - p[3]
+
+    def p_number_6(self, p):
+        '''
+        number : number MULTIPLY number
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] * p[3]
+
+    def p_number_7(self, p):
+        '''
+        number : number DIVIDE number
+        '''
+        if DEBUG:
+            self.print_p(p)
+        p[0] = p[1] / p[3]
+
     def p_int_0(self, p):
         "int : MINUS int"
         if DEBUG:
diff --git a/tests/fixtures/function.hcl b/tests/fixtures/function.hcl
new file mode 100644
index 0000000..e0b155b
--- /dev/null
+++ b/tests/fixtures/function.hcl
@@ -0,0 +1,7 @@
+data "resource" "object" {
+  vars = {
+    cluster_1         = join("\n", data.template_file.cluster_1.*.rendered)
+    cluster_2         = format("name_%02d", count.index + 1)
+    PROXY_AUTH        = join(":", [var.proxy_username, var.proxy_password])
+  }
+}
\ No newline at end of file
diff --git a/tests/fixtures/function.json b/tests/fixtures/function.json
new file mode 100644
index 0000000..c8fb17c
--- /dev/null
+++ b/tests/fixtures/function.json
@@ -0,0 +1,13 @@
+{
+  "data": {
+    "resource": {
+      "object": {
+        "vars": {
+          "cluster_1": "join('\\n',data.template_file.cluster_1.*.rendered)",
+          "cluster_2": "format(name_%02d,count.index + 1)",
+          "PROXY_AUTH": "join(':',var.proxy_username,var.proxy_password)"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/lex-fixtures/conditional_operator.hcl b/tests/lex-fixtures/conditional_operator.hcl
new file mode 100644
index 0000000..bb9e8d5
--- /dev/null
+++ b/tests/lex-fixtures/conditional_operator.hcl
@@ -0,0 +1,53 @@
+// objectitem : objectkey EQUAL objectkey QMARK objectkey COLON objectkey
+identifier1 = identifier2  ? identifier3 : identifier4
+// objectitem : objectkey EQUAL objectkey QMARK objectkey COLON number
+identifier1 = identifier2 ? identifier3 : 1
+// objectitem : objectkey EQUAL objectkey QMARK objectkey COLON BOOL
+identifier1 = identifier2 ? identifier3 : True
+// objectitem : objectkey EQUAL objectkey QMARK objectkey COLON function
+identifier1 = identifier2 ? identifier3 : element(identifier4, identifier5)
+// objectitem : objectkey EQUAL objectkey QMARK number COLON objectkey
+identifier1 = identifier2 ? 1 : identifier3
+// objectitem : objectkey EQUAL objectkey QMARK BOOL COLON objectkey
+identifier1 = identifier2 ? True : identifier3
+// objectitem : objectkey EQUAL objectkey QMARK function COLON objectkey
+identifier1 = identifier2 ? element(identifier3, identifier4) : identifier5
+// objectitem : objectkey EQUAL objectkey QMARK number COLON number
+identifier1 = identifier2 ? 1 : 2
+// objectitem : objectkey EQUAL objectkey QMARK number COLON BOOL
+identifier1 = identifier2 ? 1 : True
+// objectitem : objectkey EQUAL objectkey QMARK number COLON function
+identifier1 = identifier2 ? 1 : element(identifier3, identifier4)
+// objectitem : objectkey EQUAL objectkey QMARK BOOL COLON number
+identifier1 = identifier2 ? True : 1
+// objectitem : objectkey EQUAL objectkey QMARK BOOL COLON function
+identifier1 = identifier2 ? True : element(identifier3, identifier4)
+// objectitem : objectkey EQUAL objectkey QMARK BOOL COLON BOOL
+identifier1 = identifier2 ? True : False
+
+// objectitem : objectkey EQUAL booleanexp QMARK objectkey COLON objectkey
+identifier1 = identifier2 == identifier3 ? identifier4 : identifier5
+// objectitem : objectkey EQUAL booleanexp QMARK objectkey COLON number
+identifier1 = identifier2 == identifier3 ? identifier4 : 1
+// objectitem : objectkey EQUAL booleanexp QMARK objectkey COLON BOOL
+identifier1 = identifier2 == identifier3 ? identifier4 : True
+// objectitem : objectkey EQUAL booleanexp QMARK objectkey COLON function
+identifier1 = identifier2 == identifier3 ? identifier4 : element(identifier5, identifier6)
+// objectitem : objectkey EQUAL booleanexp QMARK number COLON objectkey
+identifier1 = identifier2 == identifier3 ? 1 : identifier4
+// objectitem : objectkey EQUAL booleanexp QMARK BOOL COLON objectkey
+identifier1 = identifier2 == identifier3 ? True : identifier4
+// objectitem : objectkey EQUAL booleanexp QMARK function COLON objectkey
+identifier1 = identifier2 == identifier3 ? element(identifier4, identifier5) : identifier6
+// objectitem : objectkey EQUAL booleanexp QMARK number COLON number
+identifier1 = identifier2 == identifier3 ? 1 : 2
+// objectitem : objectkey EQUAL booleanexp QMARK number COLON BOOL
+identifier1 = identifier2 == identifier3 ? 1 : True
+// objectitem : objectkey EQUAL booleanexp QMARK number COLON function
+identifier1 = identifier2 == identifier3 ? 1 : element(identifier4, identifier5)
+// objectitem : objectkey EQUAL booleanexp QMARK BOOL COLON number
+identifier1 = identifier2 == identifier3 ? True : 1
+// objectitem : objectkey EQUAL booleanexp QMARK BOOL COLON function
+identifier1 = identifier2 == identifier3 ? True : element(identifier4, identifier5)
+// objectitem : objectkey EQUAL booleanexp QMARK BOOL COLON BOOL
+identifier1 = identifier2 == identifier3 ? True : False
\ No newline at end of file
diff --git a/tests/lex-fixtures/terraform0.12syntax.hcl b/tests/lex-fixtures/terraform0.12syntax.hcl
new file mode 100644
index 0000000..21f13e0
--- /dev/null
+++ b/tests/lex-fixtures/terraform0.12syntax.hcl
@@ -0,0 +1,33 @@
+locals {
+  https_inbound_sg_id  = coalesce(join("", aws_security_group.https_inbound_sg.*.id), join("", data.aws_security_group.https_inbound_sg.*.id))
+}
+
+variable "env_variables" {
+  type        = map(string)
+  default     = { terraform: "needs dynamic blocks of code"}
+}
+
+resource "aws_iam_role_policy_attachment" "policy_attachment" {
+  count      = var.module_count
+  role       = aws_iam_role.role[count.index].name
+}
+
+resource "aws_rds_cluster" "interaction-database-cluster" {
+  cluster_identifier      = local.rds_name
+
+  scaling_configuration {
+    max_capacity             = 256
+    auto_pause               = var.environment == "prod" ? false : true
+    seconds_until_auto_pause = var.environment == "prod" ? null : 3600
+  }
+}
+
+resource "aws_lambda_function" "github_collector" {
+  function_name    = var.github_collector_function_name
+
+  environment {
+    variables = {
+      PROXY_AUTH    = join(":", [var.proxy_username, var.proxy_password])
+    }
+  }
+}
diff --git a/tests/test_lexer.py b/tests/test_lexer.py
index 6242188..8628116 100644
--- a/tests/test_lexer.py
+++ b/tests/test_lexer.py
@@ -98,6 +98,18 @@ class Error:
             "IDENTIFIER", "EQUAL", "STRING", None,
         ],
     ),
+    (
+        "unterminated_block_comment.hcl",
+        ["DIVIDE", "MULTIPLY", "IDENTIFIER"],
+    ),
+    (
+        "nested_comment.hcl",
+        ["MULTIPLY", "DIVIDE", None],
+    ),
+    (
+        "/not a comment",
+        ["DIVIDE", "IDENTIFIER", "IDENTIFIER", "IDENTIFIER", None],
+    ),
 ]
 
 # The first value in the tuple can be either the file that will be read or just
@@ -106,30 +118,15 @@ class Error:
     (
         "old.hcl",
         [
-            "IDENTIFIER", "EQUAL", "LEFTBRACE", "STRING", Error
+            "IDENTIFIER", "EQUAL", "LEFTBRACE", "STRING", "COLON", "STRING"
         ],
         "Line 2, column 15, index 27: Illegal character ':'"
     ),
-    (
-        "unterminated_block_comment.hcl",
-        [Error],
-        "Line 1, column 0, index 0: EOF before closing multiline comment"
-    ),
-    (
-        "nested_comment.hcl",
-        [Error],
-        "Line 5, column 0, index 13: Found '*/' before start of multiline comment"
-    ),
-    (
-        "/not a comment",
-        [Error],
-        "Line 1, column 0, index 0: Expected '//' for comment, got '/n'"
-    ),
     (
         "a = <HERE\n"
         "foobar\n"
         "HERE",
-        ["IDENTIFIER", "EQUAL", Error],
+        ["IDENTIFIER", "EQUAL", "LT", "IDENTIFIER"],
         "Line 1, column 4, index 4: Heredoc must start with '<<', got '<H'"
     ),
     (
@@ -161,21 +158,24 @@ class Error:
 @pytest.mark.parametrize("hcl_fname,tokens", LEX_FIXTURES)
 def test_lexer(hcl_fname, tokens):
 
-    with open(join(LEX_FIXTURE_DIR, hcl_fname), 'r') as fp:
-        input = fp.read()
+    if hcl_fname.endswith('.hcl'):
+        with open(join(LEX_FIXTURE_DIR, hcl_fname), 'r') as fp:
+            input = fp.read()
+    else:
+        input = hcl_fname
 
     print(input)
 
     lexer = hcl.lexer.Lexer()
     lexer.input(input)
 
-    for tok in tokens:
+    for expectedToken in tokens:
         lex_tok = lexer.token()
 
         if lex_tok is None:
-            assert tok is None
+            assert expectedToken is None
         else:
-            assert tok == lex_tok.type
+            assert expectedToken == lex_tok.type
         print(lex_tok)
 
     assert lexer.token() is None
@@ -194,18 +194,18 @@ def test_lexer_errors(hcl_fname, tokens, error_loc):
     lexer = hcl.lexer.Lexer()
     lexer.input(input)
 
-    for tok in tokens:
+    for expectedToken in tokens:
         try:
             lex_tok = lexer.token()
         except ValueError as e:
-            assert tok is Error
+            assert expectedToken is Error
             assert error_loc == str(e)
             return
 
         if lex_tok is None:
-            assert tok is None
+            assert expectedToken is None
         else:
-            assert tok == lex_tok.type
+            assert expectedToken == lex_tok.type
         print(lex_tok)
 
 f100 = 'f' * 100
@@ -233,14 +233,28 @@ def test_lexer_errors(hcl_fname, tokens, error_loc):
     (None, "/*" + f100 + "*/"),
 
     # Operators
+    ("LEFTPAREN", "("),
     ("LEFTBRACKET", "["),
     ("LEFTBRACE", "{"),
     ("COMMA", ","),
     ("PERIOD", "."),
+    ("RIGHTPAREN", ")"),
     ("RIGHTBRACKET", "]"),
     ("RIGHTBRACE", "}"),
     ("EQUAL", "="),
+    ("ADD", "+"),
     ("MINUS", "-"),
+    ("MULTIPLY", "*"),
+    ("DIVIDE", "/"),
+    ("QMARK", "?"),
+    ("COLON", ":"),
+    ("GT", ">"),
+    ("LT", "<"),
+    ("EQ", "=="),
+    ("NE", "!="),
+    ("LE", "<="),
+    ("GE", ">="),
+    ("ASTERISK_PERIOD", "*."),
 
     # Bools
     ("BOOL", "true"),
@@ -382,6 +396,7 @@ def test_tokens(token, input_string):
 # other token
 COMPLEX_TOKEN_FIXTURES = [
     # EPLUS
+    (["IDENTIFIER", "EQUAL", "LEFTBRACKET", "IDENTIFIER", "LEFTBRACKET", "NUMBER", "RIGHTBRACKET", "PERIOD", "IDENTIFIER", "RIGHTBRACKET", ], "records = [aws_elasticsearch_domain.elasticsearch[0].endpoint]"),
     (["FLOAT", "EPLUS"], "0.e"),
     (["FLOAT", "EPLUS"], "1.e+"),
     (["NUMBER", "EPLUS"], "0e"),
diff --git a/tests/test_load_dump.py b/tests/test_load_dump.py
new file mode 100644
index 0000000..5984541
--- /dev/null
+++ b/tests/test_load_dump.py
@@ -0,0 +1,99 @@
+#
+# These tests are taken from hcl/parse_test.go
+#
+
+from __future__ import print_function
+
+from os.path import join, dirname
+import hcl
+import json
+
+import pytest
+
+PARSE_FIXTURE_DIR = join(dirname(__file__), 'lex-fixtures')
+PARSE_FIXTURES = [
+    (
+        "assign_colon.hcl",
+        False,
+    ),
+    (
+        "comment.hcl",
+        False,
+    ),
+    (
+        "list_comma.hcl",
+        False,
+    ),
+    (
+        "list_of_maps.hcl",
+        False,
+    ),
+    (
+        "multiple.hcl",
+        False,
+    ),
+    (
+        "structure.hcl",
+        False,
+    ),
+    (
+        "structure_basic.hcl",
+        False,
+    ),
+    (
+        "structure_empty.hcl",
+        False,
+    ),
+    (
+        "complex.hcl",
+        False,
+    ),
+    (
+        "assign_deep.hcl",
+        False,
+    ),
+    (
+        "types.hcl",
+        False,
+    ),
+    (
+        "structure_comma.hcl",
+        False,
+    ),
+    (
+        "terraform0.12syntax.hcl",
+        False,
+    ),
+    (
+        "conditional_operator.hcl",
+        False,
+    ),
+]
+
+@pytest.mark.parametrize("hcl_fname,invalid", PARSE_FIXTURES)
+def test_parser_bytes(hcl_fname, invalid):
+    
+    with open(join(PARSE_FIXTURE_DIR, hcl_fname), 'rb') as fp:
+        
+        input = fp.read()
+        print(input)
+        
+        if not invalid:
+            hcl.loads(input)
+        else:
+            with pytest.raises(ValueError):
+                hcl.loads(input)
+                
+@pytest.mark.parametrize("hcl_fname,invalid", PARSE_FIXTURES)
+def test_parser_str(hcl_fname, invalid):
+    
+    with open(join(PARSE_FIXTURE_DIR, hcl_fname), 'r') as fp:
+        
+        input = fp.read()
+        print(input)
+        
+        if not invalid:
+            hcl.loads(input)
+        else:
+            with pytest.raises(ValueError):
+                hcl.loads(input)
diff --git a/tests/test_parser.py b/tests/test_parser.py
index 56e3b71..5984541 100644
--- a/tests/test_parser.py
+++ b/tests/test_parser.py
@@ -14,7 +14,7 @@
 PARSE_FIXTURES = [
     (
         "assign_colon.hcl",
-        True,
+        False,
     ),
     (
         "comment.hcl",
@@ -60,6 +60,14 @@
         "structure_comma.hcl",
         False,
     ),
+    (
+        "terraform0.12syntax.hcl",
+        False,
+    ),
+    (
+        "conditional_operator.hcl",
+        False,
+    ),
 ]
 
 @pytest.mark.parametrize("hcl_fname,invalid", PARSE_FIXTURES)